unsink

1 files changed, 68 insertions, 70 deletions

diff --git a/src/fzf.rs b/src/fzf.rs
index 2335375..e57ba0b 100644
--- a/src/fzf.rs
+++ b/src/fzf.rs
@@ -2,7 +2,7 @@ use {
   super::{
     argparse::Mode,
     subprocess::{stream_into, SubprocCommand},
-    types::{Abort, Fail},
+    types::Fail,
   },
   futures::future::try_join,
   std::{
@@ -51,83 +51,81 @@ async fn reset_term() -> Result<(), Fail> {
   Err(Fail::IO(PathBuf::from("reset"), ErrorKind::NotFound))
 }
 
-fn run_fzf(abort: &Arc<Abort>, cmd: SubprocCommand, stream: Receiver<OsString>) -> JoinHandle<()> {
-  let abort = abort.clone();
-
+fn run_fzf(cmd: SubprocCommand, stream: Receiver<OsString>) -> JoinHandle<()> {
   spawn(async move {
-    let subprocess = Command::new(&cmd.prog)
-      .kill_on_drop(true)
-      .args(&cmd.args)
-      .envs(&cmd.env)
-      .stdin(Stdio::piped())
-      .spawn();
+    todo!()
+    //let subprocess = Command::new(&cmd.prog)
+    //  .kill_on_drop(true)
+    //  .args(&cmd.args)
+    //  .envs(&cmd.env)
+    //  .stdin(Stdio::piped())
+    //  .spawn();
 
-    match subprocess {
-      Err(err) => {
-        abort.send(Fail::IO(cmd.prog, err.kind())).await;
-      }
-      Ok(mut child) => {
-        let mut stdin = child.stdin.take().map(BufWriter::new).expect("nil stdin");
+    //match subprocess {
+    //  Err(err) => {
+    //    abort.send(Fail::IO(cmd.prog, err.kind())).await;
+    //  }
+    //  Ok(mut child) => {
+    //    let mut stdin = child.stdin.take().map(BufWriter::new).expect("nil stdin");
 
-        let abort_1 = abort.clone();
-        let p1 = cmd.prog.clone();
-        let handle_in = spawn(async move {
-          stream_into(&abort_1, p1.clone(), &mut stdin, stream).await;
-          if let Err(err) = stdin.shutdown().await {
-            abort_1.send(Fail::IO(p1, err.kind())).await;
-          }
-        });
+    //    let abort_1 = abort.clone();
+    //    let p1 = cmd.prog.clone();
+    //    let handle_in = spawn(async move {
+    //      stream_into(&abort_1, p1.clone(), &mut stdin, stream).await;
+    //      if let Err(err) = stdin.shutdown().await {
+    //        abort_1.send(Fail::IO(p1, err.kind())).await;
+    //      }
+    //    });
 
-        let abort_2 = abort.clone();
-        let p2 = cmd.prog.clone();
-        let handle_child = spawn(async move {
-          select! {
-            () = abort_2.notified() => {
-              match child.kill().await {
-                Err(err) => {
-                  abort_2.send(Fail::IO(p2, err.kind())).await;
-                },
-                _ => {
-                  if let Err(err) = reset_term().await {
-                    abort_2.send(err).await;
-                  }
-                }
-              }
-            },
-            rhs = child.wait() => {
-              match rhs {
-                Ok(status) => {
-                  match status.code() {
-                    Some(0 | 1) | None => (),
-                    Some(130) => {
-                      abort_2.send(Fail::Interrupt).await;
-                    }
-                    Some(c) => {
-                      abort_2.send(Fail::BadExit(p2, c)).await;
-                      if let Err(err) = reset_term().await {
-                        abort_2.send(err).await;
-                      }
-                    }
-                  }
-                }
-                Err(err) => {
-                  abort_2.send(Fail::IO(p2, err.kind())).await;
-                }
-              }
-            }
-          }
-        });
+    //    let abort_2 = abort.clone();
+    //    let p2 = cmd.prog.clone();
+    //    let handle_child = spawn(async move {
+    //      select! {
+    //        () = abort_2.notified() => {
+    //          match child.kill().await {
+    //            Err(err) => {
+    //              abort_2.send(Fail::IO(p2, err.kind())).await;
+    //            },
+    //            _ => {
+    //              if let Err(err) = reset_term().await {
+    //                abort_2.send(err).await;
+    //              }
+    //            }
+    //          }
+    //        },
+    //        rhs = child.wait() => {
+    //          match rhs {
+    //            Ok(status) => {
+    //              match status.code() {
+    //                Some(0 | 1) | None => (),
+    //                Some(130) => {
+    //                  abort_2.send(Fail::Interrupt).await;
+    //                }
+    //                Some(c) => {
+    //                  abort_2.send(Fail::BadExit(p2, c)).await;
+    //                  if let Err(err) = reset_term().await {
+    //                    abort_2.send(err).await;
+    //                  }
+    //                }
+    //              }
+    //            }
+    //            Err(err) => {
+    //              abort_2.send(Fail::IO(p2, err.kind())).await;
+    //            }
+    //          }
+    //        }
+    //      }
+    //    });
 
-        if let Err(err) = try_join(handle_child, handle_in).await {
-          abort.send(err.into()).await;
-        }
-      }
-    }
+    //    if let Err(err) = try_join(handle_child, handle_in).await {
+    //      abort.send(err.into()).await;
+    //    }
+    //  }
+    //}
   })
 }
 
 pub fn stream_fzf_proc(
-  abort: &Arc<Abort>,
   bin: PathBuf,
   args: Vec<String>,
   stream: Receiver<OsString>,
@@ -166,5 +164,5 @@ pub fn stream_fzf_proc(
     args: arguments,
     env: fzf_env,
   };
-  run_fzf(abort, cmd, stream)
+  run_fzf(cmd, stream)
 }