Compare commits
3 Commits
dynamic-la
...
2af591489a
| Author | SHA1 | Date | |
|---|---|---|---|
|
2af591489a | ||
|
|
c76d1aaa53 | ||
|
|
d69be40dcd |
@@ -17,8 +17,6 @@ gleam_stdlib = ">= 0.44.0 and < 2.0.0"
|
||||
gleam_otp = ">= 1.2.0 and < 2.0.0"
|
||||
gleam_erlang = ">= 1.3.0 and < 2.0.0"
|
||||
simplifile = ">= 2.3.1 and < 3.0.0"
|
||||
gleam_json = ">= 3.1.0 and < 4.0.0"
|
||||
gleam_time = ">= 1.6.0 and < 2.0.0"
|
||||
|
||||
[dev-dependencies]
|
||||
gleeunit = ">= 1.0.0 and < 2.0.0"
|
||||
|
||||
@@ -4,19 +4,15 @@
|
||||
packages = [
|
||||
{ name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
|
||||
{ name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
|
||||
{ name = "gleam_json", version = "3.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "44FDAA8847BE8FC48CA7A1C089706BD54BADCC4C45B237A992EDDF9F2CDB2836" },
|
||||
{ name = "gleam_otp", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "BA6A294E295E428EC1562DC1C11EA7530DCB981E8359134BEABC8493B7B2258E" },
|
||||
{ name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
|
||||
{ name = "gleam_time", version = "1.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_time", source = "hex", outer_checksum = "0DF3834D20193F0A38D0EB21F0A78D48F2EC276C285969131B86DF8D4EF9E762" },
|
||||
{ name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" },
|
||||
{ name = "simplifile", version = "2.3.1", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "957E0E5B75927659F1D2A1B7B75D7B9BA96FAA8D0C53EA71C4AD9CD0C6B848F6" },
|
||||
]
|
||||
|
||||
[requirements]
|
||||
gleam_erlang = { version = ">= 1.3.0 and < 2.0.0" }
|
||||
gleam_json = { version = ">= 3.1.0 and < 4.0.0" }
|
||||
gleam_otp = { version = ">= 1.2.0 and < 2.0.0" }
|
||||
gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
|
||||
gleam_time = { version = ">= 1.6.0 and < 2.0.0" }
|
||||
gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
|
||||
simplifile = { version = ">= 2.3.1 and < 3.0.0" }
|
||||
|
||||
@@ -1,24 +1,5 @@
|
||||
import gleam/erlang/process.{type Name}
|
||||
|
||||
import musicplayer/input/input
|
||||
import musicplayer/input/key.{type Key}
|
||||
import musicplayer/logging/logging
|
||||
import musicplayer/mpv/mpv
|
||||
import musicplayer/musicplayer
|
||||
import musicplayer/ui/ui
|
||||
import gleam/io
|
||||
|
||||
pub fn main() -> Nil {
|
||||
let assert Ok(_) = logging.initialize()
|
||||
|
||||
let input_keys_name: Name(Key) = process.new_name("input_keys")
|
||||
input.new(input_keys_name)
|
||||
|
||||
let assert Ok(ui) = ui.new()
|
||||
let assert Ok(mpv) = mpv.new()
|
||||
let assert Ok(musicplayer_pid) = musicplayer.new(ui, mpv, input_keys_name)
|
||||
|
||||
let monitor = process.monitor(musicplayer_pid)
|
||||
process.new_selector()
|
||||
|> process.select_specific_monitor(monitor, fn(_) { Nil })
|
||||
|> process.selector_receive_forever
|
||||
io.println("musicplayer")
|
||||
}
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
import musicplayer/input/key.{type Key}
|
||||
|
||||
pub type Control {
|
||||
TogglePlayPause
|
||||
Search
|
||||
|
||||
Raw(String)
|
||||
Return
|
||||
Backspace
|
||||
|
||||
Exit
|
||||
}
|
||||
|
||||
pub fn from_key(key: Key) -> Result(Control, Nil) {
|
||||
case key {
|
||||
key.Return -> Ok(Return)
|
||||
key.Backspace -> Ok(Backspace)
|
||||
key.Char(char) -> Ok(char_control(char))
|
||||
_ -> Error(Nil)
|
||||
}
|
||||
}
|
||||
|
||||
fn char_control(char: String) -> Control {
|
||||
case char {
|
||||
" " -> TogglePlayPause
|
||||
"/" -> Search
|
||||
"q" -> Exit
|
||||
_ -> Raw(char)
|
||||
}
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
import gleam/erlang/process.{type Name}
|
||||
|
||||
import musicplayer/input/key.{type Key}
|
||||
|
||||
/// `new` accepts a subject that all input will be sent to
|
||||
pub fn new(input_keys_name: Name(Key)) -> Nil {
|
||||
let _ =
|
||||
process.spawn(fn() {
|
||||
let input_keys = process.named_subject(input_keys_name)
|
||||
key.read_input_until_key(input_keys)
|
||||
})
|
||||
|
||||
key.start_raw_shell()
|
||||
Nil
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
import gleam/erlang/atom
|
||||
|
||||
pub fn read_input() -> String {
|
||||
io_get_chars("", 1)
|
||||
}
|
||||
|
||||
pub type NotUsed
|
||||
|
||||
// https://www.erlang.org/doc/apps/stdlib/shell.html#start_interactive/1
|
||||
@external(erlang, "shell", "start_interactive")
|
||||
pub fn shell_start_interactive(options: #(atom.Atom, atom.Atom)) -> NotUsed
|
||||
|
||||
// https://www.erlang.org/doc/apps/stdlib/io.html#get_chars/2
|
||||
@external(erlang, "io", "get_chars")
|
||||
fn io_get_chars(prompt: String, count: Int) -> String
|
||||
@@ -1,76 +0,0 @@
|
||||
import gleam/erlang/atom
|
||||
import gleam/erlang/process.{type Subject}
|
||||
import gleam/list
|
||||
|
||||
import musicplayer/input/internal as internal_input
|
||||
|
||||
pub type Key {
|
||||
Continue(buffer: List(String))
|
||||
Char(String)
|
||||
|
||||
Left
|
||||
Right
|
||||
Up
|
||||
Down
|
||||
|
||||
Return
|
||||
Backspace
|
||||
|
||||
Unknown
|
||||
}
|
||||
|
||||
pub const esc = "\u{001B}"
|
||||
|
||||
// control sequence introducer
|
||||
pub const csi = "["
|
||||
|
||||
pub const return = "\r"
|
||||
|
||||
pub const backspace = "\u{007F}"
|
||||
|
||||
pub fn from_list(l: List(String)) -> Key {
|
||||
case l {
|
||||
[e, c, "D"] if e == esc && c == csi -> Left
|
||||
[e, c, "C"] if e == esc && c == csi -> Right
|
||||
[e, c, "A"] if e == esc && c == csi -> Up
|
||||
[e, c, "B"] if e == esc && c == csi -> Down
|
||||
|
||||
[e, c] if e == esc && c == csi -> Continue(l)
|
||||
|
||||
[e] if e == esc -> Continue(l)
|
||||
[bs] if bs == backspace -> Backspace
|
||||
[rtn] if rtn == return -> Return
|
||||
[char] -> Char(char)
|
||||
|
||||
[] -> Continue([])
|
||||
_ -> Unknown
|
||||
}
|
||||
}
|
||||
|
||||
pub fn start_raw_shell() {
|
||||
let no_shell = atom.create("noshell")
|
||||
let raw = atom.create("raw")
|
||||
internal_input.shell_start_interactive(#(no_shell, raw))
|
||||
}
|
||||
|
||||
pub fn read_input_until_key(input_keys: Subject(Key)) -> Nil {
|
||||
read_input_until_key_loop([], input_keys)
|
||||
}
|
||||
|
||||
pub fn read_input_until_key_loop(
|
||||
l: List(String),
|
||||
input_keys: Subject(Key),
|
||||
) -> Nil {
|
||||
case
|
||||
internal_input.read_input()
|
||||
|> list.wrap
|
||||
|> list.append(l, _)
|
||||
|> from_list
|
||||
{
|
||||
Continue(l) -> read_input_until_key_loop(l, input_keys)
|
||||
k -> {
|
||||
process.send(input_keys, k)
|
||||
read_input_until_key_loop([], input_keys)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
pub type Control {
|
||||
Write(String)
|
||||
|
||||
Exit
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
import gleam/result
|
||||
import gleam/string
|
||||
import gleam/time/calendar
|
||||
import gleam/time/timestamp
|
||||
import simplifile
|
||||
|
||||
const filepath = "/tmp/musicplayer.log"
|
||||
|
||||
pub fn initialize() -> Result(Nil, String) {
|
||||
case simplifile.is_file(filepath) {
|
||||
Ok(True) -> Ok(Nil)
|
||||
_ -> simplifile.create_file(filepath)
|
||||
}
|
||||
|> result.map_error(fn(e) {
|
||||
"Could not access or create log file: " <> string.inspect(e)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn log(content: String) -> Nil {
|
||||
let log_line =
|
||||
timestamp.system_time()
|
||||
|> timestamp.to_rfc3339(calendar.utc_offset)
|
||||
<> ": "
|
||||
<> content
|
||||
<> "\n"
|
||||
|
||||
// Ignore any logging errors
|
||||
let _ = simplifile.append(filepath, log_line)
|
||||
Nil
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
import gleam/erlang/process.{type Subject}
|
||||
import gleam/json
|
||||
import gleam/result
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/mpv/internal as internal_control
|
||||
import musicplayer/tcp/reason.{type Reason}
|
||||
import musicplayer/tcp/tcp.{type Socket}
|
||||
|
||||
pub type Control {
|
||||
TogglePlayPause
|
||||
|
||||
GetPlaybackTime(reply_to: Subject(Result(PlaybackTime, ControlError)))
|
||||
|
||||
Exit(reply_to: Subject(Nil))
|
||||
}
|
||||
|
||||
pub type ControlError {
|
||||
ControlError(details: String)
|
||||
}
|
||||
|
||||
pub fn toggle_play_pause(socket: Socket) -> Result(Nil, ControlError) {
|
||||
let command =
|
||||
json.object([#("command", json.array(["cycle", "pause"], of: json.string))])
|
||||
|
||||
case send_command(socket, command) {
|
||||
Error(r) -> Error(ControlError(reason.to_string(r)))
|
||||
Ok(_) -> Ok(Nil)
|
||||
}
|
||||
}
|
||||
|
||||
// https://mpv.io/manual/master/#command-interface-playback-time
|
||||
pub type PlaybackTime {
|
||||
PlaybackTime(data: Float)
|
||||
}
|
||||
|
||||
pub fn get_playback_time(socket: Socket) -> Result(PlaybackTime, ControlError) {
|
||||
let command =
|
||||
json.object([
|
||||
#(
|
||||
"command",
|
||||
json.array(["get_property_string", "playback-time"], of: json.string),
|
||||
),
|
||||
])
|
||||
|
||||
case send_command(socket, command) {
|
||||
Error(r) -> Error(ControlError(reason.to_string(r)))
|
||||
Ok(json_string) ->
|
||||
case internal_control.parse_playback_time(json_string) {
|
||||
Error(e) -> Error(ControlError(string.inspect(e)))
|
||||
Ok(data) -> Ok(PlaybackTime(data))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn send_command(socket: Socket, command: json.Json) -> Result(String, Reason) {
|
||||
result.try(tcp.send(socket, json.to_string(command) <> "\n"), fn(_) {
|
||||
let timeout_ms = 10_000
|
||||
tcp.receive(socket, timeout_ms)
|
||||
})
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
import gleam/dynamic/decode
|
||||
import gleam/float
|
||||
import gleam/json
|
||||
import gleam/string
|
||||
|
||||
pub fn parse_playback_time(
|
||||
json_string: String,
|
||||
) -> Result(Float, json.DecodeError) {
|
||||
let decoder = {
|
||||
let float_dececoder = fn(data_string) {
|
||||
case float.parse(data_string) {
|
||||
Error(_) -> decode.failure(0.0, "data")
|
||||
Ok(float_value) -> decode.success(float_value)
|
||||
}
|
||||
}
|
||||
use data <- decode.field(
|
||||
"data",
|
||||
decode.then(decode.string, float_dececoder),
|
||||
)
|
||||
|
||||
decode.success(data)
|
||||
}
|
||||
|
||||
json.parse(from: string.trim(json_string), using: decoder)
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
import gleam/erlang/process.{type Subject}
|
||||
import gleam/otp/actor
|
||||
import gleam/result
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/mpv/control.{type Control}
|
||||
import musicplayer/tcp/reason
|
||||
import musicplayer/tcp/tcp.{type Socket}
|
||||
|
||||
type State(socket) {
|
||||
State(socket: Socket)
|
||||
}
|
||||
|
||||
pub fn new() -> Result(Subject(Control), String) {
|
||||
// TODO start up mvp here, currently hi-jacking `naviterm`s socket
|
||||
let socket_path = "/tmp/naviterm_mpv"
|
||||
|
||||
case tcp.connect(socket_path) {
|
||||
Error(r) -> Error("Could not connect to mpv: " <> reason.to_string(r))
|
||||
Ok(socket) -> {
|
||||
case
|
||||
actor.new(State(socket))
|
||||
|> actor.on_message(handle_message)
|
||||
|> actor.start
|
||||
{
|
||||
Error(start_error) ->
|
||||
Error("Could not start mpv: " <> string.inspect(start_error))
|
||||
Ok(actor.Started(data: mpv, ..)) -> Ok(mpv)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_message(
|
||||
state: State(socket),
|
||||
control: Control,
|
||||
) -> actor.Next(State(socket), Control) {
|
||||
case control {
|
||||
control.TogglePlayPause -> {
|
||||
let _ =
|
||||
result.map_error(control.toggle_play_pause(state.socket), fn(err) {
|
||||
echo "Could not toggle play/pause: " <> err.details
|
||||
})
|
||||
|
||||
actor.continue(state)
|
||||
}
|
||||
|
||||
control.GetPlaybackTime(reply_to) -> {
|
||||
let res = control.get_playback_time(state.socket)
|
||||
process.send(reply_to, res)
|
||||
actor.continue(state)
|
||||
}
|
||||
|
||||
control.Exit(reply_to) -> {
|
||||
tcp.close(state.socket)
|
||||
process.send(reply_to, Nil)
|
||||
actor.stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,198 +0,0 @@
|
||||
import gleam/erlang/process.{type Name, type Pid, type Subject}
|
||||
import gleam/otp/actor
|
||||
import gleam/result
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/control.{type Control}
|
||||
import musicplayer/input/key.{type Key}
|
||||
import musicplayer/logging/logging
|
||||
import musicplayer/mpv/control as mpv_control
|
||||
import musicplayer/time/time
|
||||
import musicplayer/ui/control as ui_control
|
||||
import musicplayer/ui/layout
|
||||
|
||||
type Mode {
|
||||
Idle
|
||||
Searching
|
||||
}
|
||||
|
||||
type Input {
|
||||
Input(capturing: Bool, content: String)
|
||||
}
|
||||
|
||||
type State {
|
||||
State(
|
||||
mode: Mode,
|
||||
input: Input,
|
||||
ui: Subject(ui_control.Control),
|
||||
mpv: Subject(mpv_control.Control),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn new(
|
||||
ui: Subject(ui_control.Control),
|
||||
mpv: Subject(mpv_control.Control),
|
||||
input_keys_name: Name(Key),
|
||||
) -> Result(Pid, String) {
|
||||
let input_keys = process.named_subject(input_keys_name)
|
||||
|
||||
let input = Input(False, "")
|
||||
|
||||
case
|
||||
actor.new(State(Idle, input, ui, mpv))
|
||||
|> actor.on_message(handle_message)
|
||||
|> actor.start
|
||||
{
|
||||
Error(start_error) ->
|
||||
Error("Could not start actor: " <> string.inspect(start_error))
|
||||
Ok(actor.Started(pid:, data: musicplayer)) -> {
|
||||
logging.log("musicplayer - started")
|
||||
process.spawn(fn() {
|
||||
let assert Ok(_) = process.register(process.self(), input_keys_name)
|
||||
handle_key(musicplayer, input_keys)
|
||||
})
|
||||
|
||||
process.spawn(fn() { update_playback_time_loop(mpv, ui, 1000) })
|
||||
|
||||
Ok(pid)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_message(state: State, control: Control) -> actor.Next(State, Control) {
|
||||
case control {
|
||||
control.Search -> {
|
||||
logging.log("musicplayer - initiating search")
|
||||
|
||||
update_search(state.ui, "searching: ")
|
||||
|
||||
actor.continue(
|
||||
State(
|
||||
..state,
|
||||
mode: Searching,
|
||||
input: Input(..state.input, capturing: True),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
control.Raw(content) -> {
|
||||
logging.log("musicplayer - recieved raw input: " <> content)
|
||||
|
||||
let content = case state.mode {
|
||||
Idle -> state.input.content
|
||||
Searching -> {
|
||||
let updated = state.input.content <> content
|
||||
update_search(state.ui, "searching: " <> updated)
|
||||
updated
|
||||
}
|
||||
}
|
||||
|
||||
actor.continue(State(..state, input: Input(..state.input, content:)))
|
||||
}
|
||||
control.Backspace -> {
|
||||
logging.log("musicplayer - recieved backspace")
|
||||
|
||||
let content = case state.mode {
|
||||
Idle -> state.input.content
|
||||
Searching -> string.drop_end(state.input.content, 1)
|
||||
}
|
||||
actor.continue(State(..state, input: Input(..state.input, content:)))
|
||||
}
|
||||
control.Return -> {
|
||||
logging.log(
|
||||
"musicplayer - recieved return. `input.capture`: "
|
||||
<> "'"
|
||||
<> state.input.content
|
||||
<> "'",
|
||||
)
|
||||
|
||||
// Note: state.input.content is now the final input, use it
|
||||
// before it is reset
|
||||
case state.mode {
|
||||
Idle -> Nil
|
||||
Searching -> update_search(state.ui, "")
|
||||
}
|
||||
|
||||
actor.continue(
|
||||
State(..state, mode: Idle, input: Input(capturing: False, content: "")),
|
||||
)
|
||||
}
|
||||
|
||||
control.TogglePlayPause -> {
|
||||
logging.log("musicplayer - toggling play/pause")
|
||||
|
||||
process.send(state.mpv, mpv_control.TogglePlayPause)
|
||||
update_playback_time(state.mpv, state.ui)
|
||||
actor.continue(state)
|
||||
}
|
||||
control.Exit -> {
|
||||
logging.log("musicplayer - initiating musicplayer shutdown")
|
||||
// Close `mpv` socket
|
||||
process.call(state.mpv, 1000, fn(reply_to) { mpv_control.Exit(reply_to) })
|
||||
|
||||
// Reset terminal state (show cursor etc.)
|
||||
process.call(state.ui, 1000, fn(reply_to) { ui_control.Exit(reply_to) })
|
||||
|
||||
logging.log("musicplayer - stopped")
|
||||
|
||||
actor.stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_playback_time_loop(
|
||||
mpv: Subject(mpv_control.Control),
|
||||
ui: Subject(ui_control.Control),
|
||||
interval_ms: Int,
|
||||
) {
|
||||
process.sleep(interval_ms)
|
||||
// TODO only update if state is playing
|
||||
update_playback_time(mpv, ui)
|
||||
|
||||
update_playback_time_loop(mpv, ui, interval_ms)
|
||||
}
|
||||
|
||||
fn update_playback_time(
|
||||
mpv: Subject(mpv_control.Control),
|
||||
ui: Subject(ui_control.Control),
|
||||
) -> Nil {
|
||||
case
|
||||
process.call(mpv, 1000, fn(reply_to) {
|
||||
mpv_control.GetPlaybackTime(reply_to)
|
||||
})
|
||||
{
|
||||
Error(err) ->
|
||||
process.send(
|
||||
ui,
|
||||
ui_control.UpdateState(
|
||||
layout.PlaybackTime,
|
||||
"playback time: N/A (err: " <> err.details <> ")",
|
||||
),
|
||||
)
|
||||
|
||||
Ok(mpv_control.PlaybackTime(data: playback_time)) ->
|
||||
process.send(
|
||||
ui,
|
||||
ui_control.UpdateState(
|
||||
layout.PlaybackTime,
|
||||
"playback time: " <> time.to_duration_string(playback_time),
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn update_search(ui: Subject(ui_control.Control), content: String) -> Nil {
|
||||
process.send(ui, ui_control.UpdateState(layout.Search, content))
|
||||
}
|
||||
|
||||
/// `handle_key` listens to a subject onto which `input` will send messages with `Key`s
|
||||
fn handle_key(musicplayer: Subject(Control), input_keys: Subject(Key)) -> Nil {
|
||||
let _ =
|
||||
process.new_selector()
|
||||
|> process.select(input_keys)
|
||||
|> process.selector_receive_forever
|
||||
|> control.from_key
|
||||
|> result.map(process.send(musicplayer, _))
|
||||
|
||||
handle_key(musicplayer, input_keys)
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
import gleam/float
|
||||
import gleam/int
|
||||
import gleam/string
|
||||
|
||||
pub fn to_duration_string(seconds: Float) -> String {
|
||||
let total =
|
||||
seconds
|
||||
|> float.max(0.0)
|
||||
|> float.truncate
|
||||
|
||||
let minutes = total / 60
|
||||
let seconds = total % 60
|
||||
|
||||
let mins =
|
||||
int.to_string(minutes)
|
||||
|> string.pad_start(to: 2, with: "0")
|
||||
|
||||
let secs =
|
||||
int.to_string(seconds)
|
||||
|> string.pad_start(to: 2, with: "0")
|
||||
|
||||
mins <> ":" <> secs
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
import gleam/list
|
||||
import gleam/string
|
||||
import gleam/string_tree
|
||||
|
||||
import musicplayer/ui/internal
|
||||
|
||||
pub fn text(chars: String, x: Int, y: Int) {
|
||||
internal.chars_at(chars, x, y)
|
||||
}
|
||||
|
||||
pub fn box(x: Int, y: Int, width: Int, height: Int) -> String {
|
||||
let box_chars = #("┌", "┐", "└", "┘", "─", "│")
|
||||
let #(tl, tr, bl, br, h, v) = box_chars
|
||||
|
||||
// Add top of box
|
||||
let tree =
|
||||
string_tree.new()
|
||||
|> string_tree.append(internal.chars_at(
|
||||
tl <> string.repeat(h, width - 2) <> tr,
|
||||
x,
|
||||
y,
|
||||
))
|
||||
|
||||
// Add sides of box
|
||||
let tree_with_sides =
|
||||
list.range(1, height - 2)
|
||||
|> list.map(fn(row) {
|
||||
tree
|
||||
|> string_tree.append(internal.chars_at(v, x, y + row))
|
||||
|> string_tree.append(internal.chars_at(v, x + width - 1, y + row))
|
||||
})
|
||||
|> string_tree.concat
|
||||
|
||||
// Add bottom of box
|
||||
tree_with_sides
|
||||
|> string_tree.append(internal.chars_at(
|
||||
bl <> string.repeat(h, width - 2) <> br,
|
||||
x,
|
||||
y + height - 1,
|
||||
))
|
||||
|> string_tree.to_string
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
import gleam/erlang/process.{type Subject}
|
||||
|
||||
import musicplayer/ui/layout.{type Section}
|
||||
|
||||
pub type Control {
|
||||
UpdateDimensions(width: Int, height: Int)
|
||||
UpdateState(section: Section, content: String)
|
||||
|
||||
Exit(reply_to: Subject(Nil))
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
import gleam/int
|
||||
import gleam/io
|
||||
|
||||
// https://en.wikipedia.org/wiki/ANSI_escape_code#Control_Sequence_Introducer_commands
|
||||
|
||||
pub fn clear_screen() -> Nil {
|
||||
io.print("\u{001B}[2J\u{001B}[H")
|
||||
}
|
||||
|
||||
pub fn chars_at(chars: String, x: Int, y: Int) -> String {
|
||||
let seq = "\u{001B}[" <> int.to_string(y) <> ";" <> int.to_string(x) <> "H"
|
||||
seq <> chars
|
||||
}
|
||||
|
||||
pub fn print(chars: String) -> Nil {
|
||||
io.print(chars)
|
||||
}
|
||||
|
||||
pub fn hide_cursor() -> Nil {
|
||||
io.print("\u{001B}[?25l")
|
||||
}
|
||||
|
||||
pub fn show_cursor() -> Nil {
|
||||
io.print("\u{001B}[?25h")
|
||||
}
|
||||
|
||||
pub type Enotsup
|
||||
|
||||
// https://www.erlang.org/doc/apps/stdlib/io.html#rows/0
|
||||
@external(erlang, "io", "rows")
|
||||
pub fn io_get_rows() -> Result(Int, Enotsup)
|
||||
|
||||
// https://www.erlang.org/doc/apps/stdlib/io.html#columns/0
|
||||
@external(erlang, "io", "columns")
|
||||
pub fn io_get_columns() -> Result(Int, Enotsup)
|
||||
@@ -1,231 +0,0 @@
|
||||
import gleam/dict
|
||||
import gleam/float
|
||||
import gleam/int
|
||||
import gleam/list
|
||||
import gleam/string
|
||||
import gleam/string_tree
|
||||
|
||||
import musicplayer/logging/logging
|
||||
import musicplayer/ui/ansi
|
||||
import musicplayer/ui/internal
|
||||
|
||||
pub type Section {
|
||||
Section(String)
|
||||
|
||||
Root
|
||||
Header
|
||||
Search
|
||||
PlaybackTime
|
||||
}
|
||||
|
||||
pub type NodeType {
|
||||
Container
|
||||
Row
|
||||
Cell
|
||||
}
|
||||
|
||||
/// A Nodes width and height is in percentage (of the available width/height of its parent Node)
|
||||
pub type Node {
|
||||
Node(
|
||||
t: NodeType,
|
||||
content: String,
|
||||
width_percent: Int,
|
||||
height_percent: Int,
|
||||
children: List(Section),
|
||||
)
|
||||
}
|
||||
|
||||
pub type Layout {
|
||||
Layout(width: Int, height: Int, nodes: dict.Dict(Section, Node))
|
||||
}
|
||||
|
||||
pub fn new() -> Layout {
|
||||
let nodes =
|
||||
dict.from_list([
|
||||
#(
|
||||
Root,
|
||||
Node(
|
||||
t: Container,
|
||||
content: "Music Player",
|
||||
width_percent: 100,
|
||||
height_percent: 100,
|
||||
children: [Header, Search, PlaybackTime],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Header,
|
||||
Node(
|
||||
t: Row,
|
||||
content: "Foo (1) | Bar (2) | Baz (3)",
|
||||
width_percent: 100,
|
||||
height_percent: 33,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Search,
|
||||
Node(
|
||||
t: Row,
|
||||
content: "",
|
||||
width_percent: 100,
|
||||
height_percent: 33,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
PlaybackTime,
|
||||
Node(
|
||||
t: Row,
|
||||
content: "00:00",
|
||||
width_percent: 100,
|
||||
height_percent: 33,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
])
|
||||
Layout(width: 0, height: 0, nodes: nodes)
|
||||
}
|
||||
|
||||
pub fn update_section(
|
||||
layout: Layout,
|
||||
section: Section,
|
||||
content: String,
|
||||
) -> Layout {
|
||||
case dict.get(layout.nodes, section) {
|
||||
Error(_) -> layout
|
||||
Ok(node) ->
|
||||
Layout(
|
||||
..layout,
|
||||
nodes: dict.insert(
|
||||
layout.nodes,
|
||||
section,
|
||||
Node(..node, content: content),
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update_dimensions(layout: Layout, width: Int, height: Int) -> Layout {
|
||||
Layout(..layout, width:, height:)
|
||||
}
|
||||
|
||||
pub fn render(layout: Layout) -> Nil {
|
||||
internal.clear_screen()
|
||||
[layout.width, layout.height]
|
||||
|> list.map(int.to_string)
|
||||
|> string.join(" ")
|
||||
|> string.append("layout - render: ", _)
|
||||
|> logging.log
|
||||
|
||||
let container_width = int.to_float(layout.width)
|
||||
let container_height = int.to_float(layout.height)
|
||||
let container_top_left_x = 1
|
||||
let container_top_left_y = 1
|
||||
|
||||
let ansi_renders =
|
||||
Renders(
|
||||
box: fn(tree, x, y, w, h) {
|
||||
string_tree.append(tree, ansi.box(x, y, w, h))
|
||||
},
|
||||
text: fn(tree, chars, x, y) {
|
||||
string_tree.append(tree, ansi.text(chars, x, y))
|
||||
},
|
||||
)
|
||||
|
||||
string_tree.new()
|
||||
|> render_generic(
|
||||
layout,
|
||||
container_width,
|
||||
container_height,
|
||||
container_top_left_x,
|
||||
container_top_left_y,
|
||||
0,
|
||||
Root,
|
||||
_,
|
||||
ansi_renders,
|
||||
)
|
||||
|> string_tree.to_string
|
||||
|> internal.print
|
||||
}
|
||||
|
||||
pub type Renders(into) {
|
||||
Renders(
|
||||
text: fn(into, String, Int, Int) -> into,
|
||||
box: fn(into, Int, Int, Int, Int) -> into,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn render_generic(
|
||||
layout: Layout,
|
||||
// Dimensions
|
||||
container_width: Float,
|
||||
container_height: Float,
|
||||
container_tl_x: Int,
|
||||
container_tl_y: Int,
|
||||
// State
|
||||
index: Int,
|
||||
from: Section,
|
||||
render_into: into,
|
||||
renders: Renders(into),
|
||||
) -> into {
|
||||
case dict.get(layout.nodes, from) {
|
||||
Error(_) -> render_into
|
||||
Ok(node) -> {
|
||||
let margin = 2.0
|
||||
|
||||
let width =
|
||||
container_width *. { int.to_float(node.width_percent) /. 100.0 }
|
||||
|> float.floor
|
||||
|> float.truncate
|
||||
|
||||
let height =
|
||||
container_height *. { int.to_float(node.height_percent) /. 100.0 }
|
||||
|> float.floor
|
||||
|> float.truncate
|
||||
|
||||
let #(cx, cy) = case node.t {
|
||||
Container -> #(container_tl_x, container_tl_y)
|
||||
Row -> #(container_tl_x, container_tl_y + { index * height })
|
||||
Cell -> #(container_tl_x + { index * width }, container_tl_y)
|
||||
}
|
||||
|
||||
let parent =
|
||||
render_into
|
||||
|> renders.box(cx, cy, width, height)
|
||||
// + 2 for header margin
|
||||
|> renders.text(node.content, cx + 2, cy)
|
||||
|
||||
list.index_map(node.children, fn(child, i) { #(i, child) })
|
||||
|> list.fold(parent, fn(acc_into, ic) {
|
||||
let #(i, child) = ic
|
||||
|
||||
let cw =
|
||||
container_width
|
||||
*. { int.to_float(node.width_percent) /. 100.0 }
|
||||
-. margin
|
||||
|> float.floor
|
||||
|
||||
let ch =
|
||||
container_height
|
||||
*. { int.to_float(node.height_percent) /. 100.0 }
|
||||
-. margin
|
||||
|> float.floor
|
||||
|
||||
let child_origin_x = container_tl_x + 1
|
||||
let child_origin_y = container_tl_y + 1
|
||||
|
||||
render_generic(
|
||||
layout,
|
||||
cw,
|
||||
ch,
|
||||
child_origin_x,
|
||||
child_origin_y,
|
||||
i,
|
||||
child,
|
||||
acc_into,
|
||||
renders,
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
import gleam/dict
|
||||
|
||||
import musicplayer/ui/internal
|
||||
import musicplayer/ui/layout.{Container, Layout, Node, Section}
|
||||
import musicplayer/ui/layout_examples/wait_for_input.{wait_for_input}
|
||||
|
||||
pub fn main() {
|
||||
let assert Ok(width) = internal.io_get_columns()
|
||||
let assert Ok(height) = internal.io_get_rows()
|
||||
|
||||
two_rows_with_cells(width, height)
|
||||
|> layout.render
|
||||
|
||||
wait_for_input()
|
||||
}
|
||||
|
||||
/// Two rows:
|
||||
/// First row has two cells
|
||||
/// Second row has no cells
|
||||
fn two_rows_with_cells(width: Int, height: Int) -> layout.Layout {
|
||||
let nodes =
|
||||
dict.from_list([
|
||||
#(
|
||||
Section("Root"),
|
||||
Node(
|
||||
t: Container,
|
||||
content: "container",
|
||||
width_percent: 100,
|
||||
height_percent: 100,
|
||||
children: [
|
||||
Section("Row1"),
|
||||
Section("Row2"),
|
||||
],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("Row1"),
|
||||
Node(
|
||||
t: layout.Row,
|
||||
content: "row 1",
|
||||
width_percent: 100,
|
||||
height_percent: 50,
|
||||
children: [
|
||||
Section("A"),
|
||||
Section("A"),
|
||||
],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("A"),
|
||||
Node(
|
||||
t: layout.Cell,
|
||||
content: "cell 1",
|
||||
width_percent: 50,
|
||||
height_percent: 100,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("B"),
|
||||
Node(
|
||||
t: layout.Cell,
|
||||
content: "cell 2",
|
||||
width_percent: 50,
|
||||
height_percent: 100,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("Row2"),
|
||||
Node(
|
||||
t: layout.Row,
|
||||
content: "row 2",
|
||||
width_percent: 100,
|
||||
height_percent: 50,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
])
|
||||
|
||||
Layout(width:, height:, nodes: nodes)
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
import gleam/erlang/process.{type Name}
|
||||
|
||||
import musicplayer/input/input
|
||||
import musicplayer/input/key.{type Key}
|
||||
|
||||
pub fn wait_for_input() {
|
||||
let input_keys_name: Name(Key) = process.new_name("input_keys")
|
||||
let assert Ok(_) = process.register(process.self(), input_keys_name)
|
||||
|
||||
input.new(input_keys_name)
|
||||
|
||||
process.new_selector()
|
||||
|> process.select(process.named_subject(input_keys_name))
|
||||
|> process.selector_receive_forever
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
import gleam/erlang/process.{type Subject}
|
||||
import gleam/int
|
||||
import gleam/list
|
||||
import gleam/otp/actor
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/logging/logging
|
||||
import musicplayer/ui/control.{type Control}
|
||||
import musicplayer/ui/internal
|
||||
import musicplayer/ui/layout.{type Layout}
|
||||
|
||||
pub type State(redraw, content) {
|
||||
State(redraw: Subject(Layout), layout: Layout)
|
||||
}
|
||||
|
||||
pub fn new() -> Result(Subject(Control), String) {
|
||||
let redraw_name = process.new_name("redraw")
|
||||
let redraw: Subject(Layout) = process.named_subject(redraw_name)
|
||||
|
||||
let layout = layout.new()
|
||||
|
||||
case
|
||||
actor.new(State(redraw, layout))
|
||||
|> actor.on_message(handle_message)
|
||||
|> actor.start
|
||||
{
|
||||
Error(start_error) ->
|
||||
Error("Could not start actor: " <> string.inspect(start_error))
|
||||
Ok(actor.Started(data: ui, ..)) -> {
|
||||
process.spawn(fn() {
|
||||
let update_dimensions_interval_ms = 300
|
||||
update_dimensions_on_interval(ui, update_dimensions_interval_ms)
|
||||
})
|
||||
|
||||
process.spawn(fn() {
|
||||
let assert Ok(_) = process.register(process.self(), redraw_name)
|
||||
|
||||
internal.clear_screen()
|
||||
internal.hide_cursor()
|
||||
|
||||
redraw_loop(redraw)
|
||||
})
|
||||
|
||||
Ok(ui)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_message(
|
||||
state: State(redraw, layout),
|
||||
control: Control,
|
||||
) -> actor.Next(State(redraw, layout), Control) {
|
||||
case control {
|
||||
control.UpdateDimensions(width, height) -> {
|
||||
let current_dimensions = #(state.layout.width, state.layout.height)
|
||||
|
||||
case #(width, height) == current_dimensions {
|
||||
True -> actor.continue(state)
|
||||
False -> {
|
||||
[width, height]
|
||||
|> list.map(int.to_string)
|
||||
|> string.join(" ")
|
||||
|> string.append("ui - updating dimensions: ", _)
|
||||
|> logging.log
|
||||
|
||||
let layout = layout.update_dimensions(state.layout, width, height)
|
||||
|
||||
process.send(state.redraw, layout)
|
||||
actor.continue(State(..state, layout:))
|
||||
}
|
||||
}
|
||||
}
|
||||
control.UpdateState(section, content) -> {
|
||||
let layout = layout.update_section(state.layout, section, content)
|
||||
|
||||
actor.send(state.redraw, layout)
|
||||
actor.continue(State(..state, layout:))
|
||||
}
|
||||
|
||||
control.Exit(reply_to) -> {
|
||||
internal.show_cursor()
|
||||
process.send(reply_to, Nil)
|
||||
actor.stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn redraw_loop(redraw: Subject(Layout)) -> Nil {
|
||||
process.receive_forever(redraw)
|
||||
|> layout.render
|
||||
|
||||
redraw_loop(redraw)
|
||||
}
|
||||
|
||||
fn update_dimensions_on_interval(ui: Subject(Control), interval_ms: Int) {
|
||||
case internal.io_get_columns(), internal.io_get_rows() {
|
||||
Ok(width), Ok(height) -> {
|
||||
process.send(ui, control.UpdateDimensions(width, height))
|
||||
}
|
||||
_, _ -> logging.log("ui - failed to update dimensions")
|
||||
}
|
||||
|
||||
process.sleep(interval_ms)
|
||||
update_dimensions_on_interval(ui, interval_ms)
|
||||
}
|
||||
@@ -4,8 +4,8 @@ import gleam/otp/actor
|
||||
import gleam/result
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/tcp/reason.{type Reason}
|
||||
import musicplayer/tcp/tcp
|
||||
import tcp/reason.{type Reason}
|
||||
import tcp/tcp
|
||||
|
||||
pub type Message {
|
||||
Shutdown
|
||||
@@ -4,6 +4,8 @@ pub type Reason {
|
||||
/// from `send`
|
||||
Closed
|
||||
|
||||
Overflow
|
||||
|
||||
/// Address already in use
|
||||
Eaddrinuse
|
||||
/// Cannot assign requested address
|
||||
@@ -158,6 +160,7 @@ pub type Reason {
|
||||
|
||||
pub fn to_string(reason: Reason) -> String {
|
||||
case reason {
|
||||
Overflow -> "overflow"
|
||||
Closed -> "Connection closed (closed)"
|
||||
Eacces -> "Permission denied (eacces)"
|
||||
Eaddrinuse -> "Address already in use (eaddrinuse)"
|
||||
@@ -2,7 +2,7 @@ import gleam/bit_array
|
||||
import gleam/erlang/atom
|
||||
import gleam/result
|
||||
|
||||
import musicplayer/tcp/reason.{type Reason}
|
||||
import tcp/reason.{type Reason}
|
||||
|
||||
pub type Socket
|
||||
|
||||
@@ -105,7 +105,7 @@ fn gen_tcp_connect(
|
||||
) -> Result(Socket, Reason)
|
||||
|
||||
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#send/2
|
||||
@external(erlang, "tcp_ffi", "send")
|
||||
@external(erlang, "ipc_ffi", "send")
|
||||
fn gen_tcp_send(socket: Socket, packet: BitArray) -> Result(Nil, Reason)
|
||||
|
||||
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#close/1
|
||||
@@ -113,5 +113,5 @@ fn gen_tcp_send(socket: Socket, packet: BitArray) -> Result(Nil, Reason)
|
||||
fn gen_tcp_close(socket: Socket) -> Nil
|
||||
|
||||
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#shutdown/2
|
||||
@external(erlang, "tcp_ffi", "shutdown")
|
||||
@external(erlang, "gen_tcp", "shutdown")
|
||||
fn gen_tcp_shutdown(socket: Socket, how: atom.Atom) -> Result(Nil, Reason)
|
||||
@@ -1,24 +0,0 @@
|
||||
import gleam/list
|
||||
import gleeunit
|
||||
|
||||
import musicplayer/control.{type Control}
|
||||
import musicplayer/input/key.{type Key, Char}
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
type TestCase {
|
||||
TestCase(key: Key, expected: Result(Control, Nil))
|
||||
}
|
||||
|
||||
pub fn control_from_key_test() {
|
||||
let test_cases = [
|
||||
TestCase(Char(" "), Ok(control.TogglePlayPause)),
|
||||
TestCase(Char("q"), Ok(control.Exit)),
|
||||
]
|
||||
|
||||
list.each(test_cases, fn(tc) {
|
||||
assert tc.expected == control.from_key(tc.key)
|
||||
})
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
import gleam/list
|
||||
import gleeunit
|
||||
|
||||
import musicplayer/input/key.{type Key, Char, backspace, csi, esc, return}
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
type TestCase {
|
||||
TestCase(input: List(String), expected: Key)
|
||||
}
|
||||
|
||||
pub fn key_from_list_test() {
|
||||
let base_tests = [TestCase([], key.Continue([]))]
|
||||
|
||||
let char_tests = [TestCase(["c"], Char("c"))]
|
||||
|
||||
let escape_tests = [
|
||||
TestCase([esc, csi], key.Continue([esc, csi])),
|
||||
TestCase([esc], key.Continue([esc])),
|
||||
|
||||
TestCase([esc, csi, "D"], key.Left),
|
||||
TestCase([esc, csi, "C"], key.Right),
|
||||
TestCase([esc, csi, "A"], key.Up),
|
||||
TestCase([esc, csi, "B"], key.Down),
|
||||
]
|
||||
|
||||
let input_tests = [
|
||||
TestCase([return], key.Return),
|
||||
TestCase([backspace], key.Backspace),
|
||||
]
|
||||
|
||||
let test_cases = [base_tests, char_tests, escape_tests, input_tests]
|
||||
|
||||
list.each(list.flatten(test_cases), fn(tc) {
|
||||
assert tc.expected == key.from_list(tc.input)
|
||||
})
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
import gleeunit
|
||||
|
||||
import musicplayer/mpv/internal
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
pub fn parse_playback_time_test() {
|
||||
let json_string =
|
||||
"{\"data\":\"123.456789\",\"request_id\":0,\"error\":\"success\"}\n"
|
||||
|
||||
let assert Ok(data) = internal.parse_playback_time(json_string)
|
||||
assert data == 123.456789
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
import gleam/list
|
||||
import gleeunit
|
||||
import simplifile
|
||||
|
||||
import echo_server
|
||||
import musicplayer/tcp/tcp
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
pub fn tcp_send_shutdown_receive_test() {
|
||||
let socket_path = "/tmp/musicplayer-test.sock"
|
||||
|
||||
let assert Ok(_) = echo_server.new(socket_path)
|
||||
let assert Ok(socket) = tcp.connect(socket_path)
|
||||
|
||||
let messages = ["hello, ", "world!\n"]
|
||||
list.each(messages, fn(message) {
|
||||
let assert Ok(_) = tcp.send(socket, message)
|
||||
})
|
||||
|
||||
let assert Ok(_) = tcp.shutdown(socket)
|
||||
|
||||
let timeout_ms = 100
|
||||
assert Ok("hello, world!\n") == tcp.receive(socket, timeout_ms)
|
||||
|
||||
// TODO find better way to always do cleanup
|
||||
simplifile.delete(socket_path)
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
import gleam/list
|
||||
import gleeunit
|
||||
|
||||
import musicplayer/time/time
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
type TestCase {
|
||||
TestCase(seconds: Float, expected: String)
|
||||
}
|
||||
|
||||
pub fn to_duration_string_test() {
|
||||
let test_cases = [
|
||||
TestCase(-1.0, "00:00"),
|
||||
TestCase(0.0, "00:00"),
|
||||
TestCase(9.0, "00:09"),
|
||||
TestCase(10.0, "00:10"),
|
||||
TestCase(11.0, "00:11"),
|
||||
TestCase(60.0, "01:00"),
|
||||
TestCase(61.0, "01:01"),
|
||||
TestCase(120.0, "02:00"),
|
||||
TestCase(600.0, "10:00"),
|
||||
TestCase(6000.0, "100:00"),
|
||||
TestCase(6001.0, "100:01"),
|
||||
]
|
||||
|
||||
list.each(test_cases, fn(tc) {
|
||||
assert tc.expected == time.to_duration_string(tc.seconds)
|
||||
})
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
import gleam/dict
|
||||
import gleam/io
|
||||
import gleam/string
|
||||
import gleeunit
|
||||
import gleeunit/should
|
||||
import musicplayer/ui/virtual_ansi
|
||||
|
||||
import musicplayer/ui/layout.{Layout, Node, Section}
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
pub fn foo_test() {
|
||||
let layout =
|
||||
Layout(
|
||||
width: 80,
|
||||
height: 20,
|
||||
nodes: dict.from_list([
|
||||
#(
|
||||
Section("Root"),
|
||||
Node(
|
||||
t: layout.Container,
|
||||
content: "container",
|
||||
width_percent: 100,
|
||||
height_percent: 100,
|
||||
children: [
|
||||
Section("Row1"),
|
||||
Section("Row2"),
|
||||
],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("Row1"),
|
||||
Node(
|
||||
t: layout.Row,
|
||||
content: "row 1",
|
||||
width_percent: 100,
|
||||
height_percent: 50,
|
||||
children: [
|
||||
Section("A"),
|
||||
Section("B"),
|
||||
],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("A"),
|
||||
Node(
|
||||
t: layout.Cell,
|
||||
content: "cell 1",
|
||||
width_percent: 50,
|
||||
height_percent: 100,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("B"),
|
||||
Node(
|
||||
t: layout.Cell,
|
||||
content: "cell 2",
|
||||
width_percent: 50,
|
||||
height_percent: 100,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
#(
|
||||
Section("Row2"),
|
||||
Node(
|
||||
t: layout.Row,
|
||||
content: "row 1",
|
||||
width_percent: 100,
|
||||
height_percent: 50,
|
||||
children: [],
|
||||
),
|
||||
),
|
||||
]),
|
||||
)
|
||||
|
||||
let expected =
|
||||
"
|
||||
container──────────────────────────────────────────────────────────────────────┐
|
||||
│row 1────────────────────────────────────────────────────────────────────────┐│
|
||||
││cell 1───────────────────────────────┐cell 2───────────────────────────────┐││
|
||||
│││ ││ │││
|
||||
│││ ││ │││
|
||||
│││ ││ │││
|
||||
│││ ││ │││
|
||||
│││ ││ │││
|
||||
││└────────────────────────────────────┘└────────────────────────────────────┘││
|
||||
│└────────────────────────────────────────────────────────────────────────────┘│
|
||||
│row 1────────────────────────────────────────────────────────────────────────┐│
|
||||
││ ││
|
||||
││ ││
|
||||
││ ││
|
||||
││ ││
|
||||
││ ││
|
||||
││ ││
|
||||
││ ││
|
||||
│└────────────────────────────────────────────────────────────────────────────┘│
|
||||
└──────────────────────────────────────────────────────────────────────────────┘
|
||||
"
|
||||
|
||||
let visual =
|
||||
virtual_ansi.render(layout, Section("Root"), layout.width, layout.height)
|
||||
case visual == string.trim(expected) {
|
||||
True -> Nil
|
||||
False -> {
|
||||
io.println("Test failed")
|
||||
io.println("Expected:")
|
||||
io.println(string.trim(expected))
|
||||
|
||||
io.println("Got:")
|
||||
io.println(visual)
|
||||
|
||||
should.equal(visual, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,113 +0,0 @@
|
||||
import gleam/dict
|
||||
import gleam/int
|
||||
import gleam/list
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/ui/layout.{type Layout, type Section, Renders}
|
||||
|
||||
pub type Screen =
|
||||
dict.Dict(#(Int, Int), String)
|
||||
|
||||
pub fn render(layout: Layout, root: Section, width: Int, height: Int) -> String {
|
||||
let test_renders =
|
||||
Renders(
|
||||
box: fn(screen, x, y, w, h) { box(screen, x, y, w, h) },
|
||||
text: fn(screen, chars, x, y) { text(screen, chars, x, y) },
|
||||
)
|
||||
|
||||
let screen =
|
||||
layout.render_generic(
|
||||
layout,
|
||||
int.to_float(width),
|
||||
int.to_float(height),
|
||||
1,
|
||||
1,
|
||||
0,
|
||||
root,
|
||||
dict.new(),
|
||||
test_renders,
|
||||
)
|
||||
|
||||
screen_to_string(screen)
|
||||
}
|
||||
|
||||
pub fn screen_to_string(screen: Screen) -> String {
|
||||
let keys = dict.keys(screen)
|
||||
|
||||
// Find the bounding box of the drawing
|
||||
let max_x = list.fold(keys, 0, fn(m, k) { int.max(m, k.0) })
|
||||
let max_y = list.fold(keys, 0, fn(m, k) { int.max(m, k.1) })
|
||||
|
||||
// We start from 1 because ANSI is 1-based
|
||||
let min_y = list.fold(keys, 1000, fn(m, k) { int.min(m, k.1) })
|
||||
|
||||
list.range(min_y, max_y)
|
||||
|> list.map(fn(y) {
|
||||
list.range(1, max_x)
|
||||
|> list.map(fn(x) {
|
||||
case dict.get(screen, #(x, y)) {
|
||||
Ok(char) -> char
|
||||
Error(_) -> " "
|
||||
// Fill gaps with space
|
||||
}
|
||||
})
|
||||
|> string.join("")
|
||||
})
|
||||
|> string.join("\n")
|
||||
}
|
||||
|
||||
pub fn text(screen: Screen, text: String, start_x: Int, y: Int) -> Screen {
|
||||
// We use to_graphemes to ensure Unicode characters (like emoji or box lines)
|
||||
// are treated as single visual units
|
||||
text
|
||||
|> string.to_graphemes
|
||||
|> list.index_fold(screen, fn(acc, char, i) {
|
||||
dict.insert(acc, #(start_x + i, y), char)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn box(screen: Screen, x: Int, y: Int, w: Int, h: Int) -> Screen {
|
||||
let box_chars = #("┌", "┐", "└", "┘", "─", "│")
|
||||
let #(tl, tr, bl, br, hor, ver) = box_chars
|
||||
|
||||
// Don't draw impossible boxes
|
||||
case w < 2 || h < 2 {
|
||||
True -> screen
|
||||
False -> {
|
||||
screen
|
||||
// 1. Corners
|
||||
|> dict.insert(#(x, y), tl)
|
||||
|> dict.insert(#(x + w - 1, y), tr)
|
||||
|> dict.insert(#(x, y + h - 1), bl)
|
||||
|> dict.insert(#(x + w - 1, y + h - 1), br)
|
||||
// 2. Top and Bottom edges
|
||||
|> horizontal_line(x + 1, y, w - 2, hor)
|
||||
|> horizontal_line(x + 1, y + h - 1, w - 2, hor)
|
||||
// 3. Side edges
|
||||
|> vertical_line(x, y + 1, h - 2, ver)
|
||||
|> vertical_line(x + w - 1, y + 1, h - 2, ver)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn horizontal_line(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x + i, y), char) })
|
||||
}
|
||||
|
||||
fn vertical_line(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x, y + i), char) })
|
||||
}
|
||||
@@ -1,5 +1,38 @@
|
||||
import gleam/list
|
||||
import gleeunit
|
||||
import simplifile
|
||||
|
||||
import tcp/echo_server
|
||||
import tcp/tcp
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
}
|
||||
|
||||
pub fn foo_test() {
|
||||
let socket_path = "/tmp/musicplayer-test.sock"
|
||||
|
||||
let assert Ok(_) = echo_server.new(socket_path)
|
||||
let assert Ok(socket) = tcp.connect(socket_path)
|
||||
|
||||
let messages = ["hello, ", "world!\n"]
|
||||
list.each(messages, fn(message) {
|
||||
let assert Ok(_) = tcp.send(socket, message)
|
||||
})
|
||||
|
||||
// TODO not valid syntax?
|
||||
// let assert Ok(Nil) = tcp.shutdown(socket)
|
||||
//
|
||||
// test: musicplayer_test.foo_test
|
||||
// code: let assert Ok(Nil) = tcp.shutdown(socket)
|
||||
// value: Ok
|
||||
// info: Pattern match failed, no pattern matched the value.
|
||||
|
||||
let _ = tcp.shutdown(socket)
|
||||
|
||||
let timeout_ms = 100
|
||||
assert Ok("hello, world!\n") == tcp.receive(socket, timeout_ms)
|
||||
|
||||
// TODO find better way to always do cleanup
|
||||
simplifile.delete(socket_path)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user