sourcefrog
diff --git a/‎NEWS.md‎
Lines changed: 3 additions & 1 deletion b/‎NEWS.md‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎src/build_dir.rs‎
Lines changed: 8 additions & 7 deletions b/‎src/build_dir.rs‎
Lines changed: 8 additions & 7 deletions
diff --git a/‎src/cargo.rs‎
Lines changed: 80 additions & 111 deletions b/‎src/cargo.rs‎
Lines changed: 80 additions & 111 deletions
diff --git a/‎src/config.rs‎
Lines changed: 2 additions & 3 deletions b/‎src/config.rs‎
Lines changed: 2 additions & 3 deletions
@@ -15,6 +15,8 @@
   join existing environment variable `CARGO_MUTANTS_MINIMUM_TEST_TIMEOUT`, to allow
   boosting the minimum, especially for test environments with poor or uneven throughput.
 
+- Changed: Renamed fields in `outcomes.json` from `cargo_result` to `process_status` and from `command` to `argv`.
+
 ## 1.2.1
 
 Released 2023-01-05
@@ -71,7 +73,7 @@ Released 2022-09-24
 
 - New: `cargo mutants --completions SHELL` to generate shell completions using `clap_complete`.
 
-- Changed: `carg-mutants` no longer builds in the source directory, and no longer copies the `target/` directory to the scratch directory. Since `cargo-mutants` now sets `RUSTFLAGS` to avoid false failures from warnings, it is unlikely to match the existing build products in the source directory `target/`, and in fact building there is just likely to cause rebuilds in the source. The behavior now is as if `--no-copy-target` was always passed. That option is still accepted, but it has no effect.
+- Changed: `cargo-mutants` no longer builds in the source directory, and no longer copies the `target/` directory to the scratch directory. Since `cargo-mutants` now sets `RUSTFLAGS` to avoid false failures from warnings, it is unlikely to match the existing build products in the source directory `target/`, and in fact building there is just likely to cause rebuilds in the source. The behavior now is as if `--no-copy-target` was always passed. That option is still accepted, but it has no effect.
 
 - Changed: `cargo-mutants` finds all possible mutations before doing the baseline test, so that you can see earlier how many there will be.
 
 
@@ -1,4 +1,4 @@
-// Copyright 2021, 2022 Martin Pool
+// Copyright 2021-2023 Martin Pool
 
 //! A temporary directory containing mutated source to run cargo builds and tests.
 
@@ -42,13 +42,12 @@ impl BuildDir {
     /// Make a new build dir, copying from a source directory.
     ///
     /// [SOURCE_EXCLUDE] is excluded.
-    pub fn new(source: &dyn SourceTree, console: &Console) -> Result<BuildDir> {
-        let name_base = format!("cargo-mutants-{}-", source.path().file_name().unwrap_or(""));
+    pub fn new(source: &Utf8Path, console: &Console) -> Result<BuildDir> {
+        let name_base = format!("cargo-mutants-{}-", source.file_name().unwrap_or(""));
         let source_abs = source
-            .path()
             .canonicalize_utf8()
             .expect("canonicalize source path");
-        let temp_dir = copy_tree(source.path(), &name_base, SOURCE_EXCLUDE, console)?;
+        let temp_dir = copy_tree(source, &name_base, SOURCE_EXCLUDE, console)?;
         let path: Utf8PathBuf = temp_dir.path().to_owned().try_into().unwrap();
         fix_manifest(&path.join("Cargo.toml"), &source_abs)?;
         fix_cargo_config(&path, &source_abs)?;
@@ -139,8 +138,10 @@ mod test {
 
     #[test]
     fn build_dir_debug_form() {
-        let source_tree = CargoSourceTree::open("testdata/tree/factorial".into()).unwrap();
-        let build_dir = BuildDir::new(&source_tree, &Console::new()).unwrap();
+        let root = CargoTool::new()
+            .find_root("testdata/tree/factorial".into())
+            .unwrap();
+        let build_dir = BuildDir::new(&root, &Console::new()).unwrap();
         let debug_form = format!("{build_dir:?}");
         assert!(
             Regex::new(r#"^BuildDir \{ path: "[^"]*[/\\]cargo-mutants-factorial[^"]*" \}$"#)
 
@@ -1,11 +1,9 @@
-// Copyright 2021, 2022 Martin Pool
+// Copyright 2021-2023 Martin Pool
 
 //! Run Cargo as a subprocess, including timeouts and propagating signals.
 
 use std::env;
 use std::sync::Arc;
-use std::thread::sleep;
-use std::time::{Duration, Instant};
 
 #[allow(unused_imports)]
 use anyhow::{anyhow, bail, Context, Result};
@@ -14,56 +12,84 @@ use serde_json::Value;
 #[allow(unused_imports)]
 use tracing::{debug, error, info, span, trace, warn, Level};
 
-use crate::console::Console;
-use crate::log_file::LogFile;
 use crate::path::TreeRelativePathBuf;
-use crate::process::{get_command_output, Process, ProcessStatus};
+use crate::process::get_command_output;
+use crate::tool::Tool;
 use crate::*;
 
-/// How frequently to check if cargo finished.
-const WAIT_POLL_INTERVAL: Duration = Duration::from_millis(50);
-
-/// Run one `cargo` subprocess, with a timeout, and with appropriate handling of interrupts.
-pub fn run_cargo(
-    build_dir: &BuildDir,
-    argv: &[String],
-    log_file: &mut LogFile,
-    timeout: Duration,
-    console: &Console,
-    rustflags: &str,
-) -> Result<ProcessStatus> {
-    let start = Instant::now();
+#[derive(Debug)]
+pub struct CargoTool {
+    // environment is currently constant across all invocations.
+    env: Vec<(String, String)>,
+}
 
-    // The tests might use Insta <https://insta.rs>, and we don't want it to write
-    // updates to the source tree, and we *certainly* don't want it to write
-    // updates and then let the test pass.
+impl CargoTool {
+    pub fn new() -> CargoTool {
+        let env = vec![
+            ("CARGO_ENCODED_RUSTFLAGS".to_owned(), rustflags()),
+            // The tests might use Insta <https://insta.rs>, and we don't want it to write
+            // updates to the source tree, and we *certainly* don't want it to write
+            // updates and then let the test pass.
+            ("INSTA_UPDATE".to_owned(), "no".to_owned()),
+        ];
+        CargoTool { env }
+    }
+}
 
-    let env = [
-        ("CARGO_ENCODED_RUSTFLAGS", rustflags),
-        ("INSTA_UPDATE", "no"),
-    ];
-    debug!(?env);
+impl Tool for CargoTool {
+    fn find_root(&self, path: &Utf8Path) -> Result<Utf8PathBuf> {
+        let cargo_toml_path = locate_cargo_toml(path)?;
+        let root = cargo_toml_path
+            .parent()
+            .expect("cargo_toml_path has a parent")
+            .to_owned();
+        assert!(root.is_dir());
+        Ok(root)
+    }
 
-    let mut child = Process::start(argv, &env, build_dir.path(), timeout, log_file)?;
+    fn root_files(&self, source_root_path: &Utf8Path) -> Result<Vec<Arc<SourceFile>>> {
+        let cargo_toml_path = source_root_path.join("Cargo.toml");
+        debug!("cargo_toml_path = {}", cargo_toml_path);
+        check_interrupted()?;
+        let metadata = cargo_metadata::MetadataCommand::new()
+            .manifest_path(&cargo_toml_path)
+            .exec()
+            .context("run cargo metadata")?;
+        check_interrupted()?;
 
-    let process_status = loop {
-        if let Some(exit_status) = child.poll()? {
-            break exit_status;
-        } else {
-            console.tick();
-            sleep(WAIT_POLL_INTERVAL);
+        let mut r = Vec::new();
+        for package_metadata in &metadata.workspace_packages() {
+            debug!("walk package {:?}", package_metadata.manifest_path);
+            let package_name = Arc::new(package_metadata.name.to_string());
+            for source_path in direct_package_sources(source_root_path, package_metadata)? {
+                check_interrupted()?;
+                r.push(Arc::new(SourceFile::new(
+                    source_root_path,
+                    source_path,
+                    package_name.clone(),
+                )?));
+            }
         }
-    };
+        Ok(r)
+    }
 
-    let message = format!(
-        "cargo result: {:?} in {:.3}s",
-        process_status,
-        start.elapsed().as_secs_f64()
-    );
-    log_file.message(&message);
-    debug!(cargo_result = ?process_status, elapsed = ?start.elapsed());
-    check_interrupted()?;
-    Ok(process_status)
+    fn compose_argv(
+        &self,
+        scenario: &Scenario,
+        phase: Phase,
+        options: &Options,
+    ) -> Result<Vec<String>> {
+        Ok(cargo_argv(scenario.package_name(), phase, options))
+    }
+
+    fn compose_env(
+        &self,
+        _scenario: &Scenario,
+        _phase: Phase,
+        _options: &Options,
+    ) -> Result<Vec<(String, String)>> {
+        Ok(self.env.clone())
+    }
 }
 
 /// Return the name of the cargo binary.
@@ -76,7 +102,7 @@ fn cargo_bin() -> String {
 
 /// Make up the argv for a cargo check/build/test invocation, including argv[0] as the
 /// cargo binary itself.
-pub fn cargo_argv(package_name: Option<&str>, phase: Phase, options: &Options) -> Vec<String> {
+fn cargo_argv(package_name: Option<&str>, phase: Phase, options: &Options) -> Vec<String> {
     let mut cargo_args = vec![cargo_bin(), phase.name().to_string()];
     if phase == Phase::Check || phase == Phase::Build {
         cargo_args.push("--tests".to_string());
@@ -94,39 +120,13 @@ pub fn cargo_argv(package_name: Option<&str>, phase: Phase, options: &Options) -
     cargo_args
 }
 
-/// A source tree where we can run cargo commands.
-#[derive(Debug)]
-pub struct CargoSourceTree {
-    pub root: Utf8PathBuf,
-    cargo_toml_path: Utf8PathBuf,
-}
-
-impl CargoSourceTree {
-    /// Open the source tree enclosing the given path.
-    ///
-    /// Returns an error if it's not found.
-    pub fn open(path: &Utf8Path) -> Result<CargoSourceTree> {
-        let cargo_toml_path = locate_cargo_toml(path)?;
-        let root = cargo_toml_path
-            .parent()
-            .expect("cargo_toml_path has a parent")
-            .to_owned();
-        assert!(root.is_dir());
-
-        Ok(CargoSourceTree {
-            root,
-            cargo_toml_path,
-        })
-    }
-}
-
 /// Return adjusted CARGO_ENCODED_RUSTFLAGS, including any changes to cap-lints.
 ///
 /// This does not currently read config files; it's too complicated.
 ///
 /// See <https://doc.rust-lang.org/cargo/reference/environment-variables.html>
 /// <https://doc.rust-lang.org/rustc/lints/levels.html#capping-lints>
-pub fn rustflags() -> String {
+fn rustflags() -> String {
     let mut rustflags: Vec<String> = if let Some(rustflags) = env::var_os("CARGO_ENCODED_RUSTFLAGS")
     {
         rustflags
@@ -150,7 +150,7 @@ pub fn rustflags() -> String {
         Vec::new()
     };
     rustflags.push("--cap-lints=allow".to_owned());
-    debug!("adjusted rustflags: {:?}", rustflags);
+    // debug!("adjusted rustflags: {:?}", rustflags);
     rustflags.join("\x1f")
 }
 
@@ -173,37 +173,6 @@ fn locate_cargo_toml(path: &Utf8Path) -> Result<Utf8PathBuf> {
     Ok(cargo_toml_path)
 }
 
-impl SourceTree for CargoSourceTree {
-    fn path(&self) -> &Utf8Path {
-        &self.root
-    }
-
-    fn root_files(&self, _options: &Options) -> Result<Vec<Arc<SourceFile>>> {
-        debug!("cargo_toml_path = {}", self.cargo_toml_path);
-        check_interrupted()?;
-        let metadata = cargo_metadata::MetadataCommand::new()
-            .manifest_path(&self.cargo_toml_path)
-            .exec()
-            .context("run cargo metadata")?;
-        check_interrupted()?;
-
-        let mut r = Vec::new();
-        for package_metadata in &metadata.workspace_packages() {
-            debug!("walk package {:?}", package_metadata.manifest_path);
-            let package_name = Arc::new(package_metadata.name.to_string());
-            for source_path in direct_package_sources(&self.root, package_metadata)? {
-                check_interrupted()?;
-                r.push(Arc::new(SourceFile::new(
-                    &self.root,
-                    source_path,
-                    package_name.clone(),
-                )?));
-            }
-        }
-        Ok(r)
-    }
-}
-
 /// Find all the files that are named in the `path` of targets in a Cargo manifest that should be tested.
 ///
 /// These are the starting points for discovering source files.
@@ -320,17 +289,17 @@ mod test {
 
     #[test]
     fn error_opening_outside_of_crate() {
-        CargoSourceTree::open(Utf8Path::new("/")).unwrap_err();
+        CargoTool::new().find_root(Utf8Path::new("/")).unwrap_err();
     }
 
     #[test]
     fn open_subdirectory_of_crate_opens_the_crate() {
-        let source_tree = CargoSourceTree::open(Utf8Path::new("testdata/tree/factorial/src"))
+        let root = CargoTool::new()
+            .find_root(Utf8Path::new("testdata/tree/factorial/src"))
             .expect("open source tree from subdirectory");
-        let path = source_tree.path();
-        assert!(path.is_dir());
-        assert!(path.join("Cargo.toml").is_file());
-        assert!(path.join("src/bin/factorial.rs").is_file());
-        assert_eq!(path.file_name().unwrap(), OsStr::new("factorial"));
+        assert!(root.is_dir());
+        assert!(root.join("Cargo.toml").is_file());
+        assert!(root.join("src/bin/factorial.rs").is_file());
+        assert_eq!(root.file_name().unwrap(), OsStr::new("factorial"));
     }
 }
@@ -15,7 +15,6 @@ use anyhow::Context;
 use camino::Utf8Path;
 use serde::Deserialize;
 
-use crate::source::SourceTree;
 use crate::Result;
 
 /// Configuration read from a config file.
@@ -49,8 +48,8 @@ impl Config {
 
     /// Read the config from a tree's `.cargo/mutants.toml`, and return a default (empty)
     /// Config is the file does not exist.
-    pub fn read_tree_config(source_tree: &dyn SourceTree) -> Result<Config> {
-        let path = source_tree.path().join(".cargo").join("mutants.toml");
+    pub fn read_tree_config(source_tree_root: &Utf8Path) -> Result<Config> {
+        let path = source_tree_root.join(".cargo").join("mutants.toml");
         if path.exists() {
             Config::read_file(&path)
         } else {