feat(split): support relative and repo-relative paths

Author: claytonrcarter

git-branchless-lib/src/testing.rs

@@ -81,6 +81,9 @@ pub struct GitRunOptions {
 
     /// Additional environment variables to start the process with.
     pub env: HashMap<String, String>,
+
+    /// Subdirectory of repo to use as working directory.
+    pub subdir: Option<PathBuf>,
 }
 
 impl Git {
@@ -217,8 +220,14 @@ impl Git {
             expected_exit_code,
             input,
             env,
+            subdir,
         } = options;
 
+        let current_dir = subdir.as_ref().map_or(self.repo_path.clone(), |subdir| {
+            let mut p = self.repo_path.clone();
+            p.push(subdir);
+            p
+        });
         let env: BTreeMap<_, _> = self
             .get_base_env(*time)
             .into_iter()
@@ -229,7 +238,7 @@ impl Git {
             .collect();
         let mut command = Command::new(&self.path_to_git);
         command
-            .current_dir(&self.repo_path)
+            .current_dir(&current_dir)
             .args(args)
             .env_clear()
             .envs(&env);

git-branchless/src/commands/split.rs

@@ -119,9 +119,35 @@ pub fn split(
         }
     };
 
+    let mut message = match files_to_extract.as_slice() {
+        [] => unreachable!("Clap should have required at least 1 file"),
+        [_] => None,
+        other => Some(format!("{} files", other.len())),
+    };
+
     let mut split_tree = commit_to_split.get_tree()?;
     for file in files_to_extract.iter() {
-        let path = Path::new(&file);
+        let path = Path::new(&file).to_path_buf();
+        let cwd = std::env::current_dir()?;
+        let working_copy_path = repo
+            .get_working_copy_path()
+            .expect("FIXME running in bare root");
+
+        let path = if cwd != working_copy_path && path.exists() {
+            let mut repo_relative_path = cwd
+                .strip_prefix(working_copy_path)
+                .expect("FIXME not running in working copy?")
+                .to_path_buf();
+            repo_relative_path.push(path);
+            repo_relative_path
+        } else if let Some(stripped_filename) = file.strip_prefix(':') {
+            // https://git-scm.com/docs/gitrevisions#Documentation/gitrevisions.txt-emltngtltpathgtemegem0READMEememREADMEem
+            Path::new(stripped_filename).to_path_buf()
+        } else {
+            path
+        };
+        let path = path.as_path();
+        message = message.or(Some(path.to_string_lossy().to_string()));
 
         if let Ok(Some(false)) = commit_to_split.contains_touched_path(path) {
             writeln!(
@@ -171,17 +197,14 @@ pub fn split(
                 } else {
                     writeln!(
                         effects.get_error_stream(),
-                        "Aborting: the file '{file}' doesn't exist.",
+                        "Aborting: the file '{file}' does not exist.",
                     )?;
                 }
                 return Ok(Err(ExitCode(1)));
             }
         }
     }
-    let message = match files_to_extract.as_slice() {
-        [only_file] => only_file.clone(),
-        other => format!("{} files", other.len()),
-    };
+    let message = message.expect("at least 1 file should have been given");
 
     let split_commit_oid =
         commit_to_split.amend_commit(None, None, None, None, Some(&split_tree))?;

git-branchless/tests/test_split.rs

@@ -532,6 +532,157 @@ fn test_split_undo_works() -> eyre::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_split_supports_absolute_relative_and_repo_relative_paths() -> eyre::Result<()> {
+    let git = make_git()?;
+    git.init_repo()?;
+    git.detach_head()?;
+
+    git.write_file_txt("test1", "root contents1")?;
+    git.write_file_txt("test2", "root contents2")?;
+    git.write_file_txt("subdir/test1", "subdir contents1")?;
+    git.write_file_txt("subdir/test3", "subdir contents3")?;
+    git.run(&["add", "."])?;
+    git.run(&["commit", "-m", "first commit"])?;
+
+    {
+        let (stdout, _stderr) = git.branchless("smartlog", &[])?;
+        insta::assert_snapshot!(stdout, @r###"
+        O f777ecc (master) create initial.txt
+        |
+        @ 2998051 first commit
+        "###);
+    }
+
+    {
+        // test3.txt only exists in subdir
+
+        let (stdout, _stderr) = git.branchless_with_options(
+            "split",
+            &["HEAD", "test3.txt"],
+            &GitRunOptions {
+                subdir: Some(PathBuf::from("subdir")),
+                ..Default::default()
+            },
+        )?;
+        insta::assert_snapshot!(&stdout, @r###"
+            branchless: running command: <git-executable> checkout d9d41a308e25a71884831c865c356da43cc5294e
+            Nothing to restack.
+            O f777ecc (master) create initial.txt
+            |
+            @ d9d41a3 first commit
+            |
+            o fc76a91 temp(split): subdir/test3.txt
+        "###);
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            subdir/test1.txt | 1 +
+            test1.txt        | 1 +
+            test2.txt        | 1 +
+            3 files changed, 3 insertions(+)
+        ");
+    }
+
+    {
+        // test1.txt exists in root and subdir; try to resolve relative to cwd
+
+        git.branchless("undo", &["--yes"])?;
+
+        let (stdout, _stderr) = git.branchless_with_options(
+            "split",
+            &["HEAD", "test1.txt"],
+            &GitRunOptions {
+                subdir: Some(PathBuf::from("subdir")),
+                ..Default::default()
+            },
+        )?;
+        insta::assert_snapshot!(&stdout, @r###"
+            branchless: running command: <git-executable> checkout 0cb81546d386a2064603c05ce7dc9759591f5a93
+            Nothing to restack.
+            O f777ecc (master) create initial.txt
+            |
+            @ 0cb8154 first commit
+            |
+            o 5d2c1d0 temp(split): subdir/test1.txt
+        "###);
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            subdir/test3.txt | 1 +
+            test1.txt        | 1 +
+            test2.txt        | 1 +
+            3 files changed, 3 insertions(+)
+        ");
+    }
+
+    {
+        // test2.txt only exists in root; resolve it relative to root
+
+        git.branchless("undo", &["--yes"])?;
+
+        let (stdout, _stderr) = git.branchless_with_options(
+            "split",
+            &["HEAD", "test2.txt"],
+            &GitRunOptions {
+                subdir: Some(PathBuf::from("subdir")),
+                ..Default::default()
+            },
+        )?;
+        insta::assert_snapshot!(&stdout, @r###"
+            branchless: running command: <git-executable> checkout 912204674dfda3ab5fe089dddd1c9bf17b3c2965
+            Nothing to restack.
+            O f777ecc (master) create initial.txt
+            |
+            @ 9122046 first commit
+            |
+            o ba3abaf temp(split): test2.txt
+        "###);
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            subdir/test1.txt | 1 +
+            subdir/test3.txt | 1 +
+            test1.txt        | 1 +
+            3 files changed, 3 insertions(+)
+        ");
+    }
+
+    {
+        // test1.txt exists in root and subdir; support : to resolve relative to root
+
+        git.branchless("undo", &["--yes"])?;
+
+        let (stdout, _stderr) = git.branchless_with_options(
+            "split",
+            &["HEAD", ":test1.txt"],
+            &GitRunOptions {
+                subdir: Some(PathBuf::from("subdir")),
+                ..Default::default()
+            },
+        )?;
+        insta::assert_snapshot!(&stdout, @r###"
+            branchless: running command: <git-executable> checkout 6d0cd9b8fb1938e50250f30427a0d4865b351f2f
+            Nothing to restack.
+            O f777ecc (master) create initial.txt
+            |
+            @ 6d0cd9b first commit
+            |
+            o 2f03a38 temp(split): test1.txt
+        "###);
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            subdir/test1.txt | 1 +
+            subdir/test3.txt | 1 +
+            test2.txt        | 1 +
+            3 files changed, 3 insertions(+)
+        ");
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_split_unchanged_file() -> eyre::Result<()> {
     let git = make_git()?;