feat(switch): accept a revset as target

Author: claytonrcarter

git-branchless-navigation/src/lib.rs

@@ -25,11 +25,11 @@ use lib::core::repo_ext::RepoExt;
 use lib::util::{ExitCode, EyreExitOr};
 use tracing::{instrument, warn};
 
-use git_branchless_opts::{SwitchOptions, TraverseCommitsOptions};
-use git_branchless_revset::resolve_default_smartlog_commits;
+use git_branchless_opts::{ResolveRevsetOptions, Revset, SwitchOptions, TraverseCommitsOptions};
+use git_branchless_revset::{resolve_commits, resolve_default_smartlog_commits};
 use git_branchless_smartlog::make_smartlog_graph;
 use lib::core::config::get_next_interactive;
-use lib::core::dag::{sorted_commit_set, CommitSet, Dag};
+use lib::core::dag::{sorted_commit_set, union_all, CommitSet, Dag};
 use lib::core::effects::Effects;
 use lib::core::eventlog::{EventLogDb, EventReplayer};
 use lib::core::formatting::Pluralize;
@@ -515,17 +515,28 @@ pub fn switch(
         /// query in the commit selector.
         Interactive(String),
 
+        /// The target expression is probably a git revision or reference and
+        /// should be passed directly to git for resolution.
+        Passthrough(String),
+
+        /// The target expression should be interpreted as a revset.
+        Revset(Revset),
+
         /// No target expression was specified.
         None,
     }
     let initial_query = match (interactive, target) {
-        (true, Some(target)) => Target::Interactive(target.clone()),
+        (true, Some(target)) => Target::Interactive(target.to_string()),
         (true, None) => Target::Interactive(String::new()),
-        (false, Some(_)) => Target::None,
+        (false, Some(target)) => match repo.revparse_single_commit(target.to_string().as_ref()) {
+            Ok(Some(_)) => Target::Passthrough(target.to_string()),
+            Ok(None) | Err(_) => Target::Revset(target.clone()),
+        },
         (false, None) => Target::None,
     };
     let target: Option<CheckoutTarget> = match initial_query {
         Target::None => None,
+        Target::Passthrough(target) => Some(CheckoutTarget::Unknown(target)),
         Target::Interactive(initial_query) => {
             match prompt_select_commit(
                 None,
@@ -548,6 +559,35 @@ pub fn switch(
                 None => return Ok(Err(ExitCode(1))),
             }
         }
+        Target::Revset(target) => {
+            let commit_sets = resolve_commits(
+                effects,
+                &repo,
+                &mut dag,
+                &[target.clone()],
+                &ResolveRevsetOptions::default(),
+            )?;
+
+            let commit_set = union_all(&commit_sets);
+            let commit_set = dag.query_heads(commit_set)?;
+            let commits = sorted_commit_set(&repo, &dag, &commit_set)?;
+
+            match commits.as_slice() {
+                [commit] => Some(CheckoutTarget::Unknown(commit.get_oid().to_string())),
+                [] | [..] => {
+                    writeln!(
+                        effects.get_error_stream(),
+                        "Cannot switch to target: expected '{target}' to contain 1 head, but found {}.",
+                        commits.len()
+                    )?;
+                    writeln!(
+                        effects.get_error_stream(),
+                        "Target should be a commit or a set of commits with exactly 1 head. Aborting."
+                    )?;
+                    return Ok(Err(ExitCode(1)));
+                }
+            }
+        }
     };
 
     let additional_args = {

git-branchless-opts/src/lib.rs

@@ -172,13 +172,15 @@ pub struct SwitchOptions {
 
     /// The commit or branch to check out.
     ///
+    /// If a revset is provided, it must evaluate to set with exactly 1 head.
+    ///
     /// If this is not provided, then interactive commit selection starts as
     /// if `--interactive` were passed.
     ///
     /// If this is provided and the `--interactive` flag is passed, this
     /// text is used to pre-fill the interactive commit selector.
     #[clap(value_parser)]
-    pub target: Option<String>,
+    pub target: Option<Revset>,
 }
 
 /// Internal use.

git-branchless/tests/test_navigation.rs

@@ -851,6 +851,67 @@ fn test_navigation_switch_target_only() -> eyre::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_navigation_switch_revset() -> eyre::Result<()> {
+    let git = make_git()?;
+    git.init_repo()?;
+
+    git.detach_head()?;
+    git.commit_file("test1", 1)?;
+    git.run(&["checkout", "HEAD~"])?;
+
+    {
+        {
+            let (stdout, _stderr) = git.branchless("smartlog", &[])?;
+            insta::assert_snapshot!(stdout, @r###"
+            @ f777ecc (master) create initial.txt
+            |
+            o 62fc20d create test1.txt
+            "###);
+        }
+
+        let (stdout, _stderr) = git.branchless("switch", &["descendants(master)"])?;
+        insta::assert_snapshot!(stdout, @r###"
+        branchless: running command: <git-executable> checkout 62fc20d2a290daea0d52bdc2ed2ad4be6491010e
+        O f777ecc (master) create initial.txt
+        |
+        @ 62fc20d create test1.txt
+        "###);
+    }
+
+    git.run(&["checkout", "HEAD~"])?;
+    git.commit_file("test2", 2)?;
+    git.run(&["checkout", "HEAD~"])?;
+
+    {
+        {
+            let (stdout, _stderr) = git.branchless("smartlog", &[])?;
+            insta::assert_snapshot!(stdout, @r###"
+            @ f777ecc (master) create initial.txt
+            |\
+            | o 62fc20d create test1.txt
+            |
+            o fe65c1f create test2.txt
+            "###);
+        }
+
+        let (_stdout, stderr) = git.branchless_with_options(
+            "switch",
+            &["descendants(master)"],
+            &GitRunOptions {
+                expected_exit_code: 1,
+                ..Default::default()
+            },
+        )?;
+        insta::assert_snapshot!(stderr, @r###"
+        Cannot switch to target: expected 'descendants(master)' to contain 1 head, but found 2.
+        Target should be a commit or a set of commits with exactly 1 head. Aborting.
+        "###);
+    }
+
+    Ok(())
+}
+
 #[test]
 #[cfg(unix)]
 fn test_switch_auto_switch_interactive() -> eyre::Result<()> {