updates to status

Author: wbbradley

src/git.rs

@@ -42,7 +42,11 @@ pub(crate) fn run_git(args: &[&str]) -> Result<GitOutput> {
         .with_context(|| format!("running git {args:?}"))?;
 
     if !out.status.success() {
-        bail!("git {:?} failed with exit status: {}", args, out.status);
+        bail!(
+            "`git {}` failed with exit status: {}",
+            args.join(" "),
+            out.status
+        );
     }
     Ok(GitOutput {
         stdout: String::from_utf8_lossy(&out.stdout).trim().to_string(),
@@ -60,26 +64,28 @@ pub(crate) fn git_fetch() -> Result<()> {
 }
 
 pub(crate) fn git_branch_exists(branch: &str) -> bool {
-    run_git(&["rev-parse", "--verify", branch]).is_ok()
+    run_git(&["rev-parse", "--verify", branch]).is_ok_and(|out| !out.is_empty())
 }
 
 #[derive(Debug)]
 pub(crate) struct GitBranchStatus {
     pub(crate) exists: bool,
     pub(crate) is_descendent: bool,
+    pub(crate) parent_branch: String,
 }
 
 pub(crate) fn git_branch_status(
-    parent_branch: Option<String>,
+    parent_branch: Option<&str>,
     branch: &str,
 ) -> Result<GitBranchStatus> {
     let exists = git_branch_exists(branch);
     let parent_branch = match parent_branch {
-        Some(parent_branch) => parent_branch,
+        Some(parent_branch) => parent_branch.to_string(),
         None => git_remote_main(DEFAULT_REMOTE)?,
     };
     let is_descendent = exists && is_ancestor(&parent_branch, branch)?;
     Ok(GitBranchStatus {
+        parent_branch,
         exists,
         is_descendent,
     })

src/main.rs

@@ -75,7 +75,9 @@ fn inner_main() -> Result<()> {
     let current_branch = run_git(&["rev-parse", "--abbrev-ref", "HEAD"])?
         .output()
         .ok_or(anyhow!("No current branch?"))?;
-    let current_upstream = run_git(&["rev-parse", "--abbrev-ref", "@{upstream}"])?.output();
+    let current_upstream = run_git(&["rev-parse", "--abbrev-ref", "@{upstream}"])
+        .ok()
+        .and_then(|out| out.output());
     tracing::debug!(run_version, current_branch, current_upstream);
 
     match args.command {
@@ -95,7 +97,19 @@ fn selection_marker() -> &'static str {
     }
 }
 
-fn recur_tree(branch: &Branch, depth: usize, orig_branch: &str) {
+fn recur_tree(
+    branch: &Branch,
+    depth: usize,
+    orig_branch: &str,
+    parent_branch: Option<&str>,
+) -> Result<()> {
+    let branch_status: GitBranchStatus = git_branch_status(parent_branch, &branch.name)
+        .with_context(|| {
+            format!(
+                "attempting to fetch the branch status of {}",
+                branch.name.red()
+            )
+        })?;
     let is_current_branch = if branch.name == orig_branch {
         print!("{} ", selection_marker().purple());
         true
@@ -109,17 +123,38 @@ fn recur_tree(branch: &Branch, depth: usize, orig_branch: &str) {
     }
 
     println!(
-        "{}",
+        "{} {}",
         if is_current_branch {
             branch.name.green()
         } else {
             branch.name.truecolor(178, 178, 178)
+        },
+        {
+            let details: String = if branch_status.exists {
+                if branch_status.is_descendent {
+                    format!(
+                        "{} with {}",
+                        "is up to date".truecolor(90, 120, 87),
+                        branch_status.parent_branch.yellow()
+                    )
+                } else {
+                    format!(
+                        "{} {}",
+                        "is behind".red(),
+                        branch_status.parent_branch.yellow()
+                    )
+                }
+            } else {
+                "does not exist".red().to_string()
+            };
+            details
         }
     );
 
     for child in &branch.branches {
-        recur_tree(child, depth + 1, orig_branch);
+        recur_tree(child, depth + 1, orig_branch, Some(branch.name.as_ref()))?;
     }
+    Ok(())
 }
 
 fn status(state: State, repo: &str, orig_branch: &str) -> Result<()> {
@@ -132,7 +167,7 @@ fn status(state: State, repo: &str, orig_branch: &str) -> Result<()> {
         );
         return Ok(());
     };
-    recur_tree(tree, 0, orig_branch);
+    recur_tree(tree, 0, orig_branch, None)?;
     /*
     let stacks = state.get_stacks(repo);
     if stacks.is_empty() {

src/state.rs

@@ -54,8 +54,10 @@ impl State {
         branch_name: String,
     ) -> Result<()> {
         let branch_exists_in_tree = self.branch_exists_in_tree(repo, &branch_name);
+        let current_branch_exists_in_tree = self.branch_exists_in_tree(repo, &current_branch);
 
         if git_branch_exists(&branch_name) {
+            println!("AAA");
             if !branch_exists_in_tree {
                 tracing::warn!(
                     "Branch {branch_name} exists in the git repo but is not tracked by git-stack. \
@@ -67,35 +69,33 @@ impl State {
             run_git(&["checkout", &branch_name])?;
             return Ok(());
         }
-        // Check if the branch name already exists.
-        if branch_exists_in_tree {
-            run_git(&["checkout", &branch_name])?;
-            return Ok(());
-        }
+        // The branch does not exist in git, let's create it, and add it to the tree.
         let remote_main = git_remote_main(DEFAULT_REMOTE)?;
         let main_branch = after_text(&remote_main, format!("{DEFAULT_REMOTE}/"))
             .ok_or(anyhow!("no branch?"))?
             .to_string();
-        if current_branch == main_branch {
-            // Allow creation of the main branch for this repo if we haven't added it yet.
-            self.trees
-                .entry(repo.to_string())
-                .or_insert_with(|| Branch::new(current_branch.clone()));
-        }
+        // Ensure the main branch is in the git-stack tree for this repo if we haven't
+        // added it yet.
+        self.trees
+            .entry(repo.to_string())
+            .or_insert_with(|| Branch::new(main_branch.clone()));
+
         let branch = self
             .get_tree_branch_mut(repo, &current_branch)
-            .ok_or_else(|| anyhow::anyhow!("Branch '{current_branch}' is not being tracked."))?;
-        if !self.trees.contains_key(repo) {
-            self.trees
-                .insert(repo.to_string(), Branch::new(current_branch.clone()));
-        }
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Branch '{current_branch}' is not being tracked in the git-stack tree."
+                )
+            })?;
+
+        branch.branches.push(Branch::new(branch_name.clone()));
+
+        // Actually create the git branch.
+        run_git(&["checkout", "-b", &branch_name, &current_branch])?;
 
         // Save the state after modifying it.
         save_state(self)?;
 
-        // Checkout the new branch.
-        run_git(&["checkout", &branch_name])?;
-
         Ok(())
     }