Continuously forward Key to musicplayer on one subject

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(
+    musicplayer.new(ui, mpv, input_keys_name, input_inject_name, exit)
-      ui,
-      mpv,
-      input_keys_name,
-      input_stream_name,
-      input_inject_name,
-      exit,
-    )
   process.receive_forever(exit)
 }

src/musicplayer/input/input.gleam

@@ -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(
+pub fn new(input_keys_name: Name(Key), input_inject_name: Name(Key)) -> Nil {
-  input_keys_name: Name(Key),
-  input_stream_name: Name(List(String)),
-  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_keys: Subject(Key),
-  input_stream: Subject(List(String)),
+  input_inject: Subject(Key),
-) -> 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)
+      case l {
-      read_input_until_key(l, input_stream)
+        [ii, cmd] if ii == input_introducer -> {
+          process.send(input_keys, Continue([cmd]))
+          forward_input_to(l, input_keys)
         }
-    k -> k
+        _ -> forward_input_to(l, input_keys)
+      }
+    }
+    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)
     }
   }
@@ -137,9 +130,3 @@ fn handle_key(musicplayer: Subject(Control), input_keys: Subject(Key)) -> Nil {
 
   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)
-}