Merge pull request #1 from quodlibetor/select-upstreams

Support constructing a merge base

Author: quodlibetor

Cargo.lock

@@ -5,8 +5,8 @@ authors = ["Brandon W Maister <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-git2 = { version = "0.10.0", default_features = false }
-dialoguer = "0.1.0"
-structopt = "0.2.8"
-console = "0.6.1"
-clap = { version = "2.31.2", features = ["wrap_help"] }
+git2 = { version = "0.13.0", default_features = false }
+dialoguer = "0.5.0"
+structopt = "0.3"
+console = "0.10"
+clap = { version = "2.33", features = ["wrap_help"] }

Cargo.toml

@@ -2,20 +2,39 @@
 
 Quickly fix up an old commit using your currently-staged changes.
 
-[![asciicast](./static/asciicast.png)](https://asciinema.org/a/SYKj4ztmMJ52cSmGxSF9hHjtl?autoplay=1&t=3)
+![usage](./static/full-workflow-simple.gif)
 
 ## Usage
 
 After installation, just run `git fixup` or `git squash` to perform the related
 actions.
 
-Running `git fixup` will check if you have any staged changes (if not it will
-prompt you to stage all changes) and then present you with a list of commits
-from your current work point (HEAD) to HEAD's upstream. For example, if you are
-on `master` and its is `origin/master`, `git fixup` will show all commits
-between `master` and `origin/master`. In general this is just what you want,
-since you probably shouldn't be editing commits that other people are working
-off of.
+By default, `git fixup` checks for staged changes and offers to amend an old
+commit.
+
+Given a repo that looks like:
+
+![linear-repo](./static/00-initial-state.png)
+
+Running `git fixup` will allow you to edit an old commit:
+
+![linear-repo-fixup](./static/01-selector.gif)
+
+The default behavior will check if your current HEAD commit has an `upstream`
+branch and show you only the commits between where you currently are and that
+commit. If there is no upstream for HEAD you will see the behavior above.
+
+If you're using a pull-request workflow (e.g. github) you will often have repos that look more like this:
+
+![full-repo](./static/20-initial-full-repo.png)
+
+You can set `GIT_INSTAFIX_UPSTREAM` to a branch name and `git fixup` will only
+show changes between HEAD and the merge-base:
+
+![full-repo-fixup](./static/21-with-upstream.gif)
+
+In general this is just what you want, since you probably shouldn't be editing
+commits that other people are working off of.
 
 After you select the commit to edit, `git fixup` will apply your staged changes
 to that commit without any further prompting or work from you.

README.md

@@ -12,15 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::HashMap;
 use std::env;
 use std::error::Error;
 use std::process::Command;
 
 use console::style;
 use dialoguer::{Confirmation, Select};
-use git2::{Branch, Commit, Diff, Repository};
+use git2::{Branch, Commit, Diff, Object, ObjectType, Oid, Repository};
 use structopt::StructOpt;
 
+const UPSTREAM_VAR: &str = "GIT_INSTAFIX_UPSTREAM";
+
 #[derive(StructOpt, Debug)]
 #[structopt(
     about = "Fix a commit in your history with your currently-staged changes",
@@ -30,13 +33,15 @@ When run with no arguments this will:
 
   * If you have no staged changes, ask if you'd like to stage all changes
   * Print a `diff --stat` of your currently staged changes
-  * Provide a list of commits from HEAD to HEAD's upstream,
-    or --max-commits, whichever is lesser
+  * Provide a list of commits to fixup or amend going back to:
+      * The merge-base of HEAD and the environment var GIT_INSTAFIX_UPSTREAM
+        (if it is set)
+      * HEAD's upstream
   * Fixup your selected commit with the staged changes
 ",
-    raw(max_term_width = "100"),
-    raw(setting = "structopt::clap::AppSettings::UnifiedHelpMessage"),
-    raw(setting = "structopt::clap::AppSettings::ColoredHelp")
+    max_term_width = 100,
+    setting = structopt::clap::AppSettings::UnifiedHelpMessage,
+    setting = structopt::clap::AppSettings::ColoredHelp,
 )]
 struct Args {
     /// Use `squash!`: change the commit message that you amend
@@ -69,34 +74,71 @@ fn main() {
 
 fn run(squash: bool, max_commits: usize) -> Result<(), Box<dyn Error>> {
     let repo = Repository::open(".")?;
-    match repo.head() {
-        Ok(head) => {
-            let head_tree = head.peel_to_tree()?;
-            let head_branch = Branch::wrap(head);
-            let diff = repo.diff_tree_to_index(Some(&head_tree), None, None)?;
-            let commit_to_amend =
-                create_fixup_commit(&repo, &head_branch, &diff, squash, max_commits)?;
-            println!(
-                "selected: {} {}",
-                &commit_to_amend.id().to_string()[0..10],
-                commit_to_amend.summary().unwrap_or("")
-            );
-            // do the rebase
-            let target_id = format!("{}~", commit_to_amend.id());
-            Command::new("git")
-                .args(&["rebase", "--interactive", "--autosquash", &target_id])
-                .env("GIT_SEQUENCE_EDITOR", "true")
-                .spawn()?
-                .wait()?;
+    let head = repo
+        .head()
+        .map_err(|e| format!("HEAD is not pointing at a valid branch: {}", e))?;
+    let head_tree = head.peel_to_tree()?;
+    let head_branch = Branch::wrap(head);
+    let diff = repo.diff_tree_to_index(Some(&head_tree), None, None)?;
+    let upstream = get_upstream(&repo, &head_branch)?;
+    let commit_to_amend =
+        create_fixup_commit(&repo, &head_branch, upstream, &diff, squash, max_commits)?;
+    println!(
+        "selected: {} {}",
+        &commit_to_amend.id().to_string()[0..10],
+        commit_to_amend.summary().unwrap_or("")
+    );
+    // do the rebase
+    let target_id = format!("{}~", commit_to_amend.id());
+    Command::new("git")
+        .args(&["rebase", "--interactive", "--autosquash", &target_id])
+        .env("GIT_SEQUENCE_EDITOR", "true")
+        .spawn()?
+        .wait()?;
+    Ok(())
+}
+
+fn get_upstream<'a>(
+    repo: &'a Repository,
+    head_branch: &'a Branch,
+) -> Result<Option<Object<'a>>, Box<dyn Error>> {
+    let upstream = if let Ok(upstream_name) = env::var(UPSTREAM_VAR) {
+        let branch = repo
+            .branches(None)?
+            .filter_map(|branch| branch.ok().map(|(b, _type)| b))
+            .find(|b| {
+                b.name()
+                    .map(|n| n.expect("valid utf8 branchname") == &upstream_name)
+                    .unwrap_or(false)
+            })
+            .ok_or_else(|| format!("cannot find branch with name {:?}", upstream_name))?;
+        let result = Command::new("git")
+            .args(&[
+                "merge-base",
+                head_branch.name().unwrap().unwrap(),
+                branch.name().unwrap().unwrap(),
+            ])
+            .output()?
+            .stdout;
+        let oid = Oid::from_str(std::str::from_utf8(&result)?.trim())?;
+        let commit = repo.find_object(oid, None).unwrap();
+
+        commit
+    } else {
+        if let Ok(upstream) = head_branch.upstream() {
+            upstream.into_reference().peel(ObjectType::Commit)?
+        } else {
+            return Ok(None);
         }
-        Err(e) => return Err(format!("head is not pointing at a valid branch: {}", e).into()),
     };
-    Ok(())
+
+    Ok(Some(upstream))
 }
 
 fn create_fixup_commit<'a>(
     repo: &'a Repository,
     head_branch: &'a Branch,
+    upstream: Option<Object<'a>>,
     diff: &'a Diff,
     squash: bool,
     max_commits: usize,
@@ -106,7 +148,10 @@ fn create_fixup_commit<'a>(
         let dirty_workdir_stats = repo.diff_index_to_workdir(None, None)?.stats()?;
         if dirty_workdir_stats.files_changed() > 0 {
             print_diff(Changes::Unstaged)?;
-            if !Confirmation::new("Nothing staged, stage and commit everything?").interact()? {
+            if !Confirmation::new()
+                .with_text("Nothing staged, stage and commit everything?")
+                .interact()?
+            {
                 return Err("".into());
             }
         } else {
@@ -116,18 +161,13 @@ fn create_fixup_commit<'a>(
         let mut idx = repo.index()?;
         idx.update_all(&pathspecs, None)?;
         idx.write()?;
-        let commit_to_amend =
-            select_commit_to_amend(&repo, head_branch.upstream().ok(), max_commits)?;
-        do_fixup_commit(&repo, &head_branch, &commit_to_amend, squash)?;
-        Ok(commit_to_amend)
     } else {
         println!("Staged changes:");
         print_diff(Changes::Staged)?;
-        let commit_to_amend =
-            select_commit_to_amend(&repo, head_branch.upstream().ok(), max_commits)?;
-        do_fixup_commit(&repo, &head_branch, &commit_to_amend, squash)?;
-        Ok(commit_to_amend)
     }
+    let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits)?;
+    do_fixup_commit(&repo, &head_branch, &commit_to_amend, squash)?;
+    Ok(commit_to_amend)
 }
 
 fn do_fixup_commit<'a>(
@@ -152,13 +192,13 @@ fn do_fixup_commit<'a>(
 
 fn select_commit_to_amend<'a>(
     repo: &'a Repository,
-    upstream: Option<Branch<'a>>,
+    upstream: Option<Object<'a>>,
     max_commits: usize,
 ) -> Result<Commit<'a>, Box<dyn Error>> {
     let mut walker = repo.revwalk()?;
     walker.push_head()?;
-    let commits = if let Some(upstream) = upstream {
-        let upstream_oid = upstream.get().target().expect("No upstream target");
+    let commits = if let Some(upstream) = upstream.as_ref() {
+        let upstream_oid = upstream.id();
         walker
             .flat_map(|r| r)
             .take_while(|rev| *rev != upstream_oid)
@@ -172,19 +212,42 @@ fn select_commit_to_amend<'a>(
             .map(|rev| repo.find_commit(rev))
             .collect::<Result<Vec<_>, _>>()?
     };
+    let branches: HashMap<Oid, String> = repo
+        .branches(None)?
+        .filter_map(|b| {
+            b.ok().and_then(|(b, _type)| {
+                let name: Option<String> = b.name().ok().and_then(|n| n.map(|n| n.to_owned()));
+                let oid = b.into_reference().resolve().ok().and_then(|r| r.target());
+                name.and_then(|name| oid.map(|oid| (oid, name)))
+            })
+        })
+        .collect();
     let rev_aliases = commits
         .iter()
-        .map(|commit| {
+        .enumerate()
+        .map(|(i, commit)| {
+            let bname = if i > 0 {
+                branches
+                    .get(&commit.id())
+                    .map(|n| format!("({}) ", n))
+                    .unwrap_or_else(String::new)
+            } else {
+                String::new()
+            };
             format!(
-                "{} {}",
+                "{} {}{}",
                 &style(&commit.id().to_string()[0..10]).blue(),
+                style(bname).green(),
                 commit.summary().unwrap_or("no commit summary")
             )
         })
         .collect::<Vec<_>>();
-    let commitmsgs = rev_aliases.iter().map(|s| s.as_ref()).collect::<Vec<_>>();
-    println!("Select a commit to amend:");
-    let selected = Select::new().items(&commitmsgs).default(0).interact();
+    if upstream.is_none() {
+        eprintln!("Select a commit to amend (no upstream for HEAD):");
+    } else {
+        eprintln!("Select a commit to amend:");
+    }
+    let selected = Select::new().items(&rev_aliases).default(0).interact();
     Ok(repo.find_commit(commits[selected?].id())?)
 }