fix: resolve correct default branch name from git

Author: BrandonPacewic

src/commands/git.rs

@@ -51,6 +51,11 @@ pub fn command() -> Command {
                         .value_name("BRANCH"),
                 ),
         )
+        .subcommand(
+            Command::new("default-branch")
+                .about("Print the default branch branp would use for this repo")
+                .arg(Arg::new("remote").short('r').long("remote").help("Git remote to use").default_value("origin")),
+        )
         .subcommand(
             Command::new("ignore")
                 .about("Add repo-local ignore patterns without modifying .gitignore")
@@ -94,6 +99,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
         Some(("prs", sub)) => prs(gctx, sub),
         Some(("check", sub)) => check(gctx, sub),
         Some(("fork", sub)) => fork(gctx, sub),
+        Some(("default-branch", sub)) => default_branch(gctx, sub),
         Some(("ignore", sub)) => ignore(gctx, sub),
         Some(("open", sub)) => open(gctx, sub),
         _ => Err(CliError::from("no `git` subcommand provided")),
@@ -128,6 +134,11 @@ fn fork(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     ops::fork(gctx, &options)
 }
 
+fn default_branch(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
+    let remote = args.get_one::<String>("remote").unwrap();
+    ops::default_branch(gctx, remote)
+}
+
 fn ignore(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     let options = ops::IgnoreOptions {
         patterns: args.get_many::<String>("patterns").map(|values| values.map(String::as_str).collect()).unwrap_or_default(),

src/commands/worktree.rs

@@ -367,34 +367,7 @@ fn sync_links(gctx: &mut GlobalContext, repo: &Repo, only_worktree: Option<&Path
 }
 
 fn default_branch(repo: &Path) -> Result<String, CliError> {
-    choose_default_branch(
-        local_config_value(repo, "init.defaultBranch"),
-        remote_head_branch(repo, "origin"),
-        git::current_branch(repo).ok().flatten(),
-    )
-}
-
-fn choose_default_branch(local_config: Option<String>, remote_head: Option<String>, current_branch: Option<String>) -> Result<String, CliError> {
-    local_config
-        .or(remote_head)
-        .or(current_branch)
-        .ok_or_else(|| CliError::from("could not determine default branch from local config, origin/HEAD, or the base worktree branch"))
-}
-
-fn local_config_value(repo: &Path, key: &str) -> Option<String> {
-    git::output(repo, &["config", "--local", "--get", key]).ok().and_then(|value| non_empty_trimmed(&value))
-}
-
-fn remote_head_branch(repo: &Path, remote: &str) -> Option<String> {
-    git::output(repo, &["symbolic-ref", "--short", &format!("refs/remotes/{remote}/HEAD")])
-        .ok()
-        .and_then(|value| value.trim().strip_prefix(&format!("{remote}/")).map(str::to_string))
-        .and_then(|branch| (!branch.is_empty()).then_some(branch))
-}
-
-fn non_empty_trimmed(value: &str) -> Option<String> {
-    let value = value.trim();
-    (!value.is_empty()).then(|| value.to_string())
+    git::default_branch(repo, "origin")
 }
 
 fn session_name_for(base: &Path, name: &str) -> String {
@@ -957,16 +930,3 @@ fn required_many<'a>(args: &'a ArgMatches, name: &str) -> Result<Vec<&'a str>, C
 fn path_arg(path: &Path) -> String {
     path.to_string_lossy().to_string()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn chooses_default_branch_from_best_local_signal() {
-        assert_eq!(choose_default_branch(Some("dev".to_string()), Some("master".to_string()), Some("feature".to_string())).unwrap(), "dev");
-        assert_eq!(choose_default_branch(None, Some("dev".to_string()), Some("feature".to_string())).unwrap(), "dev");
-        assert_eq!(choose_default_branch(None, None, Some("dev".to_string())).unwrap(), "dev");
-        assert!(choose_default_branch(None, None, None).is_err());
-    }
-}

src/ops/git.rs

@@ -97,7 +97,7 @@ pub fn fork(gctx: &mut GlobalContext, options: &ForkOptions<'_>) -> CliResult {
 
     let branch = match options.branch {
         Some(branch) => branch.to_string(),
-        None => default_branch(gctx, options.remote)?,
+        None => crate::utils::git::default_branch(gctx.cwd(), options.remote)?,
     };
 
     switch_to_branch(gctx, options.remote, &branch)?;
@@ -110,6 +110,12 @@ pub fn fork(gctx: &mut GlobalContext, options: &ForkOptions<'_>) -> CliResult {
     Ok(())
 }
 
+pub fn default_branch(gctx: &mut GlobalContext, remote: &str) -> CliResult {
+    let branch = crate::utils::git::default_branch(gctx.cwd(), remote)?;
+    gctx.shell().note(branch);
+    Ok(())
+}
+
 pub fn ignore(gctx: &mut GlobalContext, options: &IgnoreOptions<'_>) -> CliResult {
     let repo_root = repo_root(gctx.cwd())?;
     let exclude_path = local_exclude_path(gctx.cwd())?;
@@ -500,18 +506,6 @@ fn add_or_reuse_remote(gctx: &mut GlobalContext, remote: &str, url: &str) -> Cli
     }
 }
 
-fn default_branch(gctx: &mut GlobalContext, remote: &str) -> Result<String, CliError> {
-    let output = crate::utils::git::output(gctx.cwd(), &["remote", "show", remote])
-        .map_err(|e| CliError::from(format!("failed to determine default branch for `{remote}`: {}; pass --branch", e.message)))?;
-
-    output
-        .lines()
-        .find_map(|line| line.trim().strip_prefix("HEAD branch: "))
-        .filter(|branch| !branch.is_empty() && *branch != "(unknown)")
-        .map(str::to_string)
-        .ok_or_else(|| CliError::from(format!("failed to determine default branch for `{remote}`; pass --branch")))
-}
-
 fn switch_to_branch(gctx: &mut GlobalContext, remote: &str, branch: &str) -> CliResult {
     match crate::utils::git::run(gctx.cwd(), &["switch", branch]) {
         Ok(()) => Ok(()),

src/utils/git.rs

@@ -43,6 +43,63 @@ pub fn remote_branches(repo: &Path, remote: &str) -> Result<HashSet<String>, Cli
         .collect())
 }
 
+pub fn default_branch(repo: &Path, remote: &str) -> Result<String, CliError> {
+    choose_default_branch(
+        local_config_value(repo, "branp.worktree.defaultBranch"),
+        live_remote_head_branch(repo, remote),
+        current_branch(repo).ok().flatten(),
+        cached_remote_head_branch(repo, remote),
+        local_config_value(repo, "init.defaultBranch"),
+    )
+}
+
+fn choose_default_branch(
+    explicit_config: Option<String>,
+    live_remote_head: Option<String>,
+    current_branch: Option<String>,
+    cached_remote_head: Option<String>,
+    init_default_branch: Option<String>,
+) -> Result<String, CliError> {
+    explicit_config
+        .and_then(|branch| non_empty_trimmed(&branch))
+        .or_else(|| live_remote_head.and_then(|branch| non_empty_trimmed(&branch)))
+        .or_else(|| current_branch.and_then(|branch| non_empty_trimmed(&branch)))
+        .or_else(|| cached_remote_head.and_then(|branch| non_empty_trimmed(&branch)))
+        .or_else(|| init_default_branch.and_then(|branch| non_empty_trimmed(&branch)))
+        .ok_or_else(|| {
+            CliError::from(
+                "could not determine default branch from branp.worktree.defaultBranch, origin HEAD, the current branch, origin/HEAD, or init.defaultBranch",
+            )
+        })
+}
+
+fn local_config_value(repo: &Path, key: &str) -> Option<String> {
+    output(repo, &["config", "--local", "--get", key]).ok().and_then(|value| non_empty_trimmed(&value))
+}
+
+fn live_remote_head_branch(repo: &Path, remote: &str) -> Option<String> {
+    output(repo, &["ls-remote", "--symref", remote, "HEAD"]).ok().and_then(|output| parse_remote_head(&output))
+}
+
+fn parse_remote_head(output: &str) -> Option<String> {
+    output
+        .lines()
+        .find_map(|line| line.strip_prefix("ref: refs/heads/").and_then(|line| line.strip_suffix("\tHEAD")).map(str::to_string))
+        .and_then(|branch| (!branch.is_empty()).then_some(branch))
+}
+
+fn cached_remote_head_branch(repo: &Path, remote: &str) -> Option<String> {
+    output(repo, &["symbolic-ref", "--short", &format!("refs/remotes/{remote}/HEAD")])
+        .ok()
+        .and_then(|value| value.trim().strip_prefix(&format!("{remote}/")).map(str::to_string))
+        .and_then(|branch| (!branch.is_empty()).then_some(branch))
+}
+
+fn non_empty_trimmed(value: &str) -> Option<String> {
+    let value = value.trim();
+    (!value.is_empty()).then(|| value.to_string())
+}
+
 pub fn delete_local_branch(repo: &Path, branch: &str, force: bool) -> CliResult {
     if !local_branch_exists(repo, branch)? {
         return Ok(());
@@ -72,3 +129,47 @@ fn parse_github_url(url: &str) -> Option<GitHubRepo> {
 
     Some(GitHubRepo { owner: owner.to_string(), name: name.to_string() })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn chooses_default_branch_from_best_available_signal() {
+        assert_eq!(
+            choose_default_branch(
+                Some("configured".to_string()),
+                Some("remote".to_string()),
+                Some("base".to_string()),
+                Some("cached".to_string()),
+                Some("init".to_string()),
+            )
+            .unwrap(),
+            "configured"
+        );
+        assert_eq!(
+            choose_default_branch(None, Some("remote".to_string()), Some("base".to_string()), Some("cached".to_string()), Some("init".to_string()))
+                .unwrap(),
+            "remote"
+        );
+        assert_eq!(
+            choose_default_branch(None, None, Some("base".to_string()), Some("cached".to_string()), Some("init".to_string())).unwrap(),
+            "base"
+        );
+        assert_eq!(choose_default_branch(None, None, None, Some("cached".to_string()), Some("init".to_string())).unwrap(), "cached");
+        assert_eq!(choose_default_branch(None, None, None, None, Some("init".to_string())).unwrap(), "init");
+        assert!(choose_default_branch(None, None, None, None, None).is_err());
+    }
+
+    #[test]
+    fn current_branch_beats_stale_cached_remote_head() {
+        assert_eq!(choose_default_branch(None, None, Some("dev".to_string()), Some("master".to_string()), None).unwrap(), "dev");
+    }
+
+    #[test]
+    fn parses_live_remote_head() {
+        let output = "ref: refs/heads/dev\tHEAD\nf7dbd99e3616315c360db815f2a09e03d38ac669\tHEAD\n";
+        assert_eq!(parse_remote_head(output).as_deref(), Some("dev"));
+        assert_eq!(parse_remote_head("f7dbd99e3616315c360db815f2a09e03d38ac669\tHEAD\n"), None);
+    }
+}