Add Search section

And remove any `input_introducer` markers to allow sections
like `Search` show the "clean" input stream

src/musicplayer.gleam

@@ -8,7 +8,6 @@ import musicplayer/ui/ui
 
 pub fn main() -> Nil {
   let input_keys_name: Name(Key) = process.new_name("input_keys")
-  let input_stream_name: Name(List(String)) = process.new_name("input_stream")
 
   // `input_inject` is created by name to allow the `input` process that
   // owns `read_input` to be able to register and receive from it,
@@ -17,20 +16,13 @@ pub fn main() -> Nil {
   let input_inject_name: Name(Key) = process.new_name("input_inject_keys")
 
   // TODO should input.new just return the inject_subject?
-  input.new(input_keys_name, input_stream_name, input_inject_name)
+  input.new(input_keys_name, input_inject_name)
 
   let assert Ok(ui) = ui.new()
   let assert Ok(mpv) = mpv.new()
 
   let exit = process.new_subject()
   let assert Ok(_) =
-    musicplayer.new(
-      ui,
-      mpv,
-      input_keys_name,
-      input_stream_name,
-      input_inject_name,
-      exit,
-    )
+    musicplayer.new(ui, mpv, input_keys_name, input_inject_name, exit)
   process.receive_forever(exit)
 }

src/musicplayer/control.gleam

@@ -2,13 +2,16 @@ import musicplayer/input/key.{type Key}
 
 pub type Control {
   TogglePlayPause
-  Search
+
+  Input(String)
+  Search(List(String))
 
   Exit
 }
 
 pub fn from_key(key: Key) -> Result(Control, Nil) {
   case key {
+    key.Input(content) -> Ok(Input(content))
     key.Char(char) -> char_control(char)
     _ -> Error(Nil)
   }
@@ -17,7 +20,7 @@ pub fn from_key(key: Key) -> Result(Control, Nil) {
 fn char_control(char: String) -> Result(Control, Nil) {
   case char {
     " " -> Ok(TogglePlayPause)
-    "/" -> Ok(Search)
+    "/" -> Ok(Search([]))
     "q" -> Ok(Exit)
     _ -> Error(Nil)
   }

src/musicplayer/input/input.gleam

@@ -1,4 +1,4 @@
-import gleam/erlang/process.{type Name, type Subject}
+import gleam/erlang/process.{type Name}
 
 import musicplayer/input/key.{type Key}
 
@@ -10,38 +10,17 @@ import musicplayer/input/key.{type Key}
 /// and
 ///   - a subject name that is used to create a `Subject` that other processes
 ///     know they can inject a `Key` into the input with
-pub fn new(
-  input_keys_name: Name(Key),
-  input_stream_name: Name(List(String)),
-  input_inject_name: Name(Key),
-) -> Nil {
+pub fn new(input_keys_name: Name(Key), input_inject_name: Name(Key)) -> Nil {
   let _ =
     process.spawn(fn() {
       let input_keys = process.named_subject(input_keys_name)
-      let input_stream = process.named_subject(input_stream_name)
       let input_inject = process.named_subject(input_inject_name)
 
       let assert Ok(_) = process.register(process.self(), input_inject_name)
 
-      read_input(input_keys, input_stream, input_inject)
+      key.read_input_until_key(input_keys, input_inject)
     })
 
   key.start_raw_shell()
   Nil
 }
-
-fn read_input(
-  input_keys: Subject(Key),
-  input_stream: Subject(List(String)),
-  input_inject: Subject(Key),
-) -> Nil {
-  let buffer = case process.receive(input_inject, 1) {
-    Ok(key.Continue(buffer)) -> buffer
-    Ok(_) | Error(_) -> []
-  }
-
-  key.read_input_until_key(buffer, input_stream)
-  |> process.send(input_keys, _)
-
-  read_input(input_keys, input_stream, input_inject)
-}

src/musicplayer/input/key.gleam

@@ -61,9 +61,19 @@ pub fn start_raw_shell() {
 }
 
 pub fn read_input_until_key(
-  l: List(String),
-  input_stream: Subject(List(String)),
-) -> Key {
+  input_keys: Subject(Key),
+  input_inject: Subject(Key),
+) -> Nil {
+  case process.receive(input_inject, 1) {
+    Ok(Continue(buffer)) -> buffer
+    Ok(_) | Error(_) -> []
+  }
+  |> forward_input_to(input_keys)
+
+  read_input_until_key(input_keys, input_inject)
+}
+
+pub fn forward_input_to(l: List(String), input_keys: Subject(Key)) -> Nil {
   case
     internal_input.read_input()
     |> list.wrap
@@ -71,9 +81,14 @@ pub fn read_input_until_key(
     |> from_list
   {
     Continue(l) -> {
-      process.send(input_stream, l)
-      read_input_until_key(l, input_stream)
+      case l {
+        [ii, cmd] if ii == input_introducer -> {
+          process.send(input_keys, Continue([cmd]))
+          forward_input_to(l, input_keys)
+        }
+        _ -> forward_input_to(l, input_keys)
+      }
     }
-    k -> k
+    k -> process.send(input_keys, k)
   }
 }

src/musicplayer/musicplayer.gleam

@@ -23,12 +23,10 @@ pub fn new(
   ui: Subject(ui_control.Control),
   mpv: Subject(mpv_control.Control),
   input_keys_name: Name(Key),
-  input_stream_name: Name(List(String)),
   input_inject_name: Name(Key),
   exit: Subject(Nil),
 ) -> Result(Nil, String) {
   let input_keys = process.named_subject(input_keys_name)
-  let input_stream = process.named_subject(input_stream_name)
   let input_inject = process.named_subject(input_inject_name)
 
   case
@@ -46,11 +44,6 @@ pub fn new(
 
       process.spawn(fn() { update_playback_time_loop(mpv, ui, 1000) })
 
-      process.spawn(fn() {
-        let assert Ok(_) = process.register(process.self(), input_stream_name)
-        temp_input_stream(input_stream)
-      })
-
       Ok(Nil)
     }
   }
@@ -61,11 +54,20 @@ fn handle_message(
   control: Control,
 ) -> actor.Next(State(ui, mpv, input_inject, exit), Control) {
   case control {
-    control.Search -> {
+    control.Search([]) -> {
       process.send(state.input_inject, key.Continue([key.input_introducer]))
-
+      update_search(state.ui, "searching: ")
       actor.continue(state)
     }
+    control.Search(content) -> {
+      update_search(state.ui, "searching: " <> string.join(content, ""))
+      actor.continue(state)
+    }
+    control.Input(_) -> {
+      update_search(state.ui, "")
+      actor.continue(state)
+    }
+
     control.TogglePlayPause -> {
       echo "toggling play/pause"
 
@@ -127,19 +129,26 @@ fn update_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
 /// parsed `Key`s which will be mapped to `Control`s (if possible)
 fn handle_key(musicplayer: Subject(Control), input_keys: Subject(Key)) -> Nil {
-  let _ =
-    process.receive_forever(input_keys)
-    |> control.from_key
-    |> result.map(process.send(musicplayer, _))
+  let _ = case
+    process.new_selector()
+    |> process.select(input_keys)
+    |> process.selector_receive_forever
+  {
+    key.Continue(buffer:) ->
+      Ok(process.send(musicplayer, control.Search(buffer)))
+
+    key ->
+      key
+      |> control.from_key
+      |> result.map(process.send(musicplayer, _))
+  }
 
   handle_key(musicplayer, input_keys)
 }
-
-fn temp_input_stream(input_stream: Subject(List(String))) -> Nil {
-  let stream = process.receive_forever(input_stream)
-  echo "input stream: " <> string.inspect(stream)
-  temp_input_stream(input_stream)
-}

src/musicplayer/ui/control.gleam

@@ -3,7 +3,6 @@ import gleam/erlang/process.{type Subject}
 import musicplayer/ui/layout.{type Section}
 
 pub type Control {
-  Redraw
   UpdateState(section: Section, content: String)
 
   Exit(reply_to: Subject(Nil))

src/musicplayer/ui/layout.gleam

@@ -7,6 +7,7 @@ pub type Layout {
 pub type Section {
   Root
   Header
+  Search
   PlaybackTime
 }
 
@@ -19,11 +20,14 @@ pub fn new() -> Layout {
     dict.from_list([
       #(
         Root,
-        Node(content: "Music Player", x: 1, y: 1, children: [
+        Node(content: "", x: 0, y: 0, children: [
           Header,
+          Search,
           PlaybackTime,
         ]),
       ),
+      #(Header, Node(content: "Music Player", x: 1, y: 1, children: [])),
+      #(Search, Node(content: "", x: 30, y: 1, children: [])),
       #(PlaybackTime, Node(content: "00:00", x: 1, y: 2, children: [])),
     ])
 

src/musicplayer/ui/ui.gleam

@@ -35,8 +35,6 @@ pub fn new() -> Result(Subject(Control), String) {
         redraw_on_update_loop(redraw)
       })
 
-      process.spawn(fn() { redraw_on_tick_loop(ui, 1000) })
-
       Ok(ui)
     }
   }
@@ -47,10 +45,6 @@ fn handle_message(
   control: Control,
 ) -> actor.Next(State(redraw, layout), Control) {
   case control {
-    control.Redraw -> {
-      actor.send(state.redraw, state.layout)
-      actor.continue(state)
-    }
     control.UpdateState(section, content) -> {
       let layout = layout.update_section(state.layout, section, content)
       let state = State(..state, layout:)
@@ -76,13 +70,6 @@ fn redraw_on_update_loop(redraw: Subject(Layout)) -> Nil {
   redraw_on_update_loop(redraw)
 }
 
-fn redraw_on_tick_loop(ui: Subject(Control), interval_ms: Int) {
-  process.sleep(interval_ms)
-  process.send(ui, control.Redraw)
-
-  redraw_on_tick_loop(ui, interval_ms)
-}
-
 fn render_layout(layout: Layout, from: Section) -> Nil {
   case dict.get(layout.nodes, from) {
     Error(_) -> Nil