add actions on process_lines

Author: zeegomo

src/cmd/actions.rs

@@ -0,0 +1,63 @@
+/// Represents actions that are available while reading live output from a process
+pub struct Actions {
+    lines: Vec<String>,
+}
+
+impl<'a> Actions {
+    pub(crate) fn new() -> Self {
+        Actions { lines: Vec::new() }
+    }
+
+    pub(crate) fn next_input(&mut self, input: &str) {
+        self.lines = vec![input.to_string()];
+    }
+
+    pub(crate) fn take_lines(&mut self) -> Vec<String> {
+        std::mem::take(&mut self.lines)
+    }
+
+    /// Replace last read line with new_lines
+    pub fn replace_with_lines(&mut self, new_lines: impl Iterator<Item = &'a str>) {
+        self.lines = new_lines.map(|str| str.to_string()).collect();
+    }
+
+    /// Remove last read line from output
+    pub fn remove_line(&mut self) {
+        self.lines = Vec::new();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Actions;
+    #[test]
+    fn test_replace() {
+        let mut actions = Actions::new();
+
+        actions.next_input("lorem");
+        actions.replace_with_lines("ipsum".split("\n"));
+        assert_eq!(actions.take_lines(), vec!["ipsum"]);
+
+        actions.next_input("lorem ipsum dolor");
+        actions.replace_with_lines("lorem ipsum dolor".split(" "));
+        assert_eq!(actions.take_lines(), vec!["lorem", "ipsum", "dolor"]);
+
+        // assert last input is discarded
+        assert_eq!(actions.take_lines(), Vec::<String>::new());
+    }
+
+    #[test]
+    fn test_remove() {
+        let mut actions = Actions::new();
+        actions.next_input("lorem");
+        actions.remove_line();
+        assert_eq!(actions.take_lines(), Vec::<String>::new());
+    }
+
+    #[test]
+    fn test_no_actions() {
+        let mut actions = Actions::new();
+        actions.next_input("lorem ipsum dolor");
+        assert_eq!(actions.take_lines(), vec!["lorem ipsum dolor"]);
+    }
+}

src/cmd/mod.rs

@@ -1,7 +1,9 @@
 //! Command execution and sandboxing.
 
+mod actions;
 mod sandbox;
 
+pub use actions::Actions;
 pub use sandbox::*;
 
 use crate::native;
@@ -125,7 +127,7 @@ pub struct Command<'w, 'pl> {
     binary: Binary,
     args: Vec<OsString>,
     env: Vec<(OsString, OsString)>,
-    process_lines: Option<&'pl mut dyn FnMut(&str)>,
+    process_lines: Option<&'pl mut dyn FnMut(&str, &mut Actions)>,
     cd: Option<PathBuf>,
     timeout: Option<Duration>,
     no_output_timeout: Option<Duration>,
@@ -240,7 +242,7 @@ impl<'w, 'pl> Command<'w, 'pl> {
     /// let mut ice = false;
     /// Command::new(&workspace, "cargo")
     ///     .args(&["build", "--all"])
-    ///     .process_lines(&mut |line| {
+    ///     .process_lines(&mut |line, _| {
     ///         if line.contains("internal compiler error") {
     ///             ice = true;
     ///         }
@@ -249,7 +251,7 @@ impl<'w, 'pl> Command<'w, 'pl> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn process_lines(mut self, f: &'pl mut dyn FnMut(&str)) -> Self {
+    pub fn process_lines(mut self, f: &'pl mut dyn FnMut(&str, &mut Actions)) -> Self {
         self.process_lines = Some(f);
         self
     }
@@ -480,7 +482,7 @@ impl OutputKind {
 
 fn log_command(
     mut cmd: StdCommand,
-    mut process_lines: Option<&mut dyn FnMut(&str)>,
+    mut process_lines: Option<&mut dyn FnMut(&str, &mut Actions)>,
     capture: bool,
     timeout: Option<Duration>,
     no_output_timeout: Option<Duration>,
@@ -512,6 +514,7 @@ fn log_command(
         .map(|line| (OutputKind::Stderr, line));
 
     let start = Instant::now();
+    let mut actions = Actions::new();
 
     let output = stdout
         .select(stderr)
@@ -541,13 +544,15 @@ fn log_command(
         .fold(
             (Vec::new(), Vec::new()),
             move |mut res, (kind, line)| -> Result<_, Error> {
+                actions.next_input(&line);
+
                 if let Some(f) = &mut process_lines {
-                    f(&line);
+                    f(&line, &mut actions);
                 }
                 if capture {
                     match kind {
-                        OutputKind::Stdout => res.0.push(line),
-                        OutputKind::Stderr => res.1.push(line),
+                        OutputKind::Stdout => res.0.append(&mut actions.take_lines()),
+                        OutputKind::Stderr => res.1.append(&mut actions.take_lines()),
                     }
                 }
                 Ok(res)

src/crates/git.rs

@@ -1,4 +1,5 @@
 use super::CrateTrait;
+use crate::cmd::Actions;
 use crate::cmd::Command;
 use crate::prepare::PrepareError;
 use crate::Workspace;
@@ -83,7 +84,7 @@ impl CrateTrait for GitRepo {
         //    fata: credential helper '{path}' told us to quit
         //
         let mut private_repository = false;
-        let mut detect_private_repositories = |line: &str| {
+        let mut detect_private_repositories = |line: &str, _actions: &mut Actions| {
             if line.starts_with("fatal: credential helper") && line.ends_with("told us to quit") {
                 private_repository = true;
             }

src/prepare.rs

@@ -109,7 +109,7 @@ impl<'a> Prepare<'a> {
         }
         let res = cmd
             .cd(self.source_dir)
-            .process_lines(&mut |line| {
+            .process_lines(&mut |line, _| {
                 if line.contains("failed to select a version for the requirement") {
                     yanked_deps = true;
                 }
@@ -130,7 +130,7 @@ impl<'a> Prepare<'a> {
         let res = Command::new(self.workspace, self.toolchain.cargo())
             .args(&["fetch", "--locked", "--manifest-path", "Cargo.toml"])
             .cd(&self.source_dir)
-            .process_lines(&mut |line| {
+            .process_lines(&mut |line, _| {
                 if line.ends_with(
                     "Cargo.lock needs to be updated but --locked was passed to prevent this",
                 ) {

src/toolchain.rs

@@ -324,7 +324,7 @@ impl Toolchain {
         let result = Command::new(workspace, &RUSTUP)
             .args(&[thing.as_str(), "list", "--installed", "--toolchain", name])
             .log_output(false)
-            .process_lines(&mut |line| {
+            .process_lines(&mut |line, _| {
                 if line.starts_with("error: toolchain ") && line.ends_with(" is not installed") {
                     not_installed = true;
                 }