implement diff

Author: wbbradley

src/git.rs

@@ -41,6 +41,13 @@ pub(crate) fn shas_match(ref1: &str, ref2: &str) -> bool {
     }
 }
 
+/// Run a git command and return the output. If the git command fails, this will return an error.
+pub(crate) fn run_git_passthrough(args: &[&str]) -> Result<ExitStatus> {
+    tracing::debug!("Running `git {}`", args.join(" "));
+    let mut child = Command::new("git").args(args).spawn()?;
+    Ok(child.wait()?)
+}
+
 /// Run a git command and return the output. If the git command fails, this will return an error.
 pub(crate) fn run_git(args: &[&str]) -> Result<GitOutput> {
     tracing::debug!("Running `git {}`", args.join(" "));

src/main.rs

@@ -43,16 +43,29 @@ enum Commands {
         #[arg(long, short)]
         branch: Option<String>,
     },
-    /// Create a new branch and make it a descendent of the current branch.
-    Checkout { branch_name: String },
+    /// Shows the diff between the given branch and its parent (git-stack tree) branch.
+    Diff {
+        /// Specifies the branch whose diff should be shown. If ommitted, the current branch will
+        /// be used.
+        branch: Option<String>,
+    },
+    /// Create a new branch and make it a descendent of the current branch. If the branch already
+    /// exists, then it will simply be checked out.
+    Checkout {
+        /// The name of the branch to check out.
+        branch_name: String,
+    },
     /// Mount the current branch on top of the named parent branch. If no parent branch is named,
     /// then the trunk branch will be used.
     Mount {
         /// The name of the parent branch upon which to stack the current branch.
         parent_branch: Option<String>,
     },
     /// Delete a branch from the git-stack tree.
-    Delete { branch_name: String },
+    Delete {
+        /// The name of the branch to delete.
+        branch_name: String,
+    },
 }
 
 fn main() {
@@ -106,9 +119,27 @@ fn inner_main() -> Result<()> {
         Commands::Mount { parent_branch } => state.mount(&repo, &current_branch, parent_branch),
         Commands::Status => status(state, &repo, &current_branch),
         Commands::Delete { branch_name } => state.delete_branch(&repo, &branch_name),
+        Commands::Diff { branch } => diff(state, &repo, &branch.unwrap_or(current_branch)),
     }
 }
 
+fn diff(state: State, repo: &str, branch: &str) -> Result<()> {
+    let parent_branch = state
+        .get_parent_branch_of(repo, branch)
+        .ok_or_else(|| anyhow!("No parent branch found for current branch: {}", branch))?;
+    tracing::debug!(
+        parent_branch = &parent_branch.name,
+        branch = branch,
+        "Diffing branches"
+    );
+    let status =
+        git::run_git_passthrough(&["diff", &format!("{}..{}", &parent_branch.name, branch)])?;
+    if !status.success() {
+        bail!("git format-patch failed");
+    }
+    Ok(())
+}
+
 fn selection_marker() -> &'static str {
     if cfg!(target_os = "windows") {
         ">"

src/state.rs

@@ -57,7 +57,6 @@ impl State {
         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. \
@@ -93,6 +92,11 @@ impl State {
         // Actually create the git branch.
         run_git(&["checkout", "-b", &branch_name, &current_branch])?;
 
+        println!(
+            "Branch {branch_name} created and checked out.",
+            branch_name = branch_name.yellow()
+        );
+
         // Save the state after modifying it.
         save_state(self)?;
 
@@ -153,6 +157,11 @@ impl State {
             bail!("Branch {branch_name} not found in the git-stack tree.");
         };
         tree.branches.retain(|branch| branch.name != branch_name);
+        println!(
+            "Branch {branch_name} removed from git-stack tree.",
+            branch_name = branch_name.yellow()
+        );
+
         save_state(self)?;
 
         Ok(())
@@ -189,7 +198,7 @@ impl State {
             );
         }
 
-        tracing::info!("Mounting {branch_name} on {parent_branch:?}");
+        tracing::debug!("Mounting {branch_name} on {parent_branch:?}");
 
         // Make sure the parent branch is actually changing.
         if let (Some(Branch { name: name_a, .. }), Some(Branch { name: name_b, .. })) = (
@@ -220,15 +229,25 @@ impl State {
         } else {
             bail!("Parent branch {parent_branch} not found in the git-stack tree.");
         }
+        println!(
+            "Branch {branch_name} stacked on {parent_branch}.",
+            branch_name = branch_name.yellow(),
+            parent_branch = parent_branch.yellow()
+        );
+
         save_state(self)?;
         Ok(())
     }
-    fn get_parent_branch_of(&self, repo: &str, branch_name: &str) -> Option<&Branch> {
+    pub fn get_parent_branch_of(&self, repo: &str, branch_name: &str) -> Option<&Branch> {
         self.trees
             .get(repo)
             .and_then(|tree| find_parent_of_branch(tree, branch_name))
     }
-    fn get_parent_branch_of_mut(&mut self, repo: &str, branch_name: &str) -> Option<&mut Branch> {
+    pub fn get_parent_branch_of_mut(
+        &mut self,
+        repo: &str,
+        branch_name: &str,
+    ) -> Option<&mut Branch> {
         self.trees
             .get_mut(repo)
             .and_then(|tree| find_parent_of_branch_mut(tree, branch_name))
@@ -366,7 +385,7 @@ pub fn load_state() -> anyhow::Result<State> {
 
 pub fn save_state(state: &State) -> Result<()> {
     let config_path = get_xdg_path()?;
-    tracing::info!(?state, ?config_path, "Saving state to config file");
+    tracing::debug!(?state, ?config_path, "Saving state to config file");
     Ok(fs::write(config_path, serde_yaml::to_string(&state)?)?)
 }