git-smart 0.1.3 → 0.1.4

data/git-smart.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{git-smart}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Glen Maddern"]
-  s.date = %q{2011-01-04}
+  s.date = %q{2011-01-05}
   s.default_executable = %q{git-smart}
   s.description = %q{Installs some additional 'smart' git commands, like `git smart-pull`.}
   s.email = %q{glenmaddern@gmail.com}
@@ -26,7 +26,11 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "bin/git-smart",
+    "docs/images/git-smart.png",
+    "docs/smart-merge.html",
+    "docs/smart-pull.html",
     "git-smart.gemspec",
+    "lib/commands/smart-merge.rb",
     "lib/commands/smart-pull.rb",
     "lib/core_ext/array.rb",
     "lib/core_ext/hash.rb",
@@ -37,6 +41,8 @@ Gem::Specification.new do |s|
     "lib/git-smart/git_repo.rb",
     "lib/git-smart/git_smart.rb",
     "lib/git-smart/safe_shell.rb",
+    "spec/smart-merge_failures_spec.rb",
+    "spec/smart-merge_spec.rb",
     "spec/smart-pull_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -46,6 +52,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Add some smarts to your git workflow}
   s.test_files = [
+    "spec/smart-merge_failures_spec.rb",
+    "spec/smart-merge_spec.rb",
     "spec/smart-pull_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -60,12 +68,14 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rocco>, [">= 0"])
     else
       s.add_dependency(%q<colorize>, [">= 0"])
       s.add_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_dependency(%q<rcov>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rocco>, [">= 0"])
     end
   else
     s.add_dependency(%q<colorize>, [">= 0"])
@@ -73,6 +83,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<rcov>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rocco>, [">= 0"])
   end
 end
 

data/lib/commands/smart-merge.rb

@@ -0,0 +1,63 @@
+#Calling `git smart-merge branchname` will, quite simply, perform a
+#non-fast-forward merge wrapped in a stash push/pop, if that's required.
+#With some helpful extra output.
+GitSmart.register 'smart-merge' do |repo, args|
+  #Let's begin!
+  current_branch = repo.current_branch
+  start "Starting: smart-merge on branch '#{current_branch}'"
+
+  #Grab the merge_target the user specified
+  merge_target = args.shift
+  failure "Usage: git smart-merge ref" if !merge_target
+
+  #Make sure git can resolve the reference to the merge_target
+  merge_sha = repo.sha(merge_target)
+  failure "Branch to merge '#{merge_target}' not recognised by git!" if !merge_sha
+
+  #If the SHA of HEAD and the merge_target are the same, we're trying to merge
+  #the same commit with itself. Which is madness!
+  head = repo.sha('HEAD')
+  if merge_sha == head
+    note "Branch '#{merge_target}' has no new commits. Nothing to merge in."
+    success 'Already up-to-date.'
+  else
+    #Determine the merge-base of the two commits, so we can report some useful output
+    #about how many new commits have been added.
+    merge_base = repo.merge_base(head, merge_sha)
+
+    #Report the number of commits on merge_target we're about to merge in.
+    new_commits_on_merge_target = repo.rev_list(merge_base, merge_target)
+    puts "Branch '#{merge_target}' has diverged by #{new_commits_on_merge_target.length} commit#{'s' if new_commits_on_merge_target.length != 1}. Merging in."
+
+    #Determine if our branch has moved on.
+    if head == merge_base
+      #Note: Even though we _can_ fast-forward here, it's a really bad idea since
+      #it results in the disappearance of the branch in history. For a good discussion
+      #on this topic, see this [StackOverflow question](http://stackoverflow.com/questions/2850369/why-uses-git-fast-forward-merging-per-default).
+      note "Branch '#{current_branch}' has not moved on since '#{merge_target}' diverged. Running with --no-ff anyway, since a fast-forward is unexpected behaviour."
+    else
+      #Report how many commits on our branch since merge_target diverged.
+      new_commits_on_branch = repo.rev_list(merge_base, head)
+      puts "Branch '#{current_branch}' has #{new_commits_on_branch.length} new commit#{'s' if new_commits_on_merge_target.length != 1} since '#{merge_target}' diverged."
+    end
+
+    #Before we merge, detect if there are local changes and stash them.
+    stash_required = repo.dirty?
+    if stash_required
+      note "Working directory dirty. Stashing..."
+      repo.stash!
+    end
+
+    #Perform the merge, using --no-ff.
+    repo.merge_no_ff!(merge_target)
+
+    #If we stashed before, pop now.
+    if stash_required
+      note "Reapplying local changes..."
+      repo.stash_pop!
+    end
+
+    #Display a nice completion message in large, friendly letters.
+    success "All good. Created merge commit #{repo.sha('HEAD')[0,7]}."
+  end
+end

data/lib/commands/smart-pull.rb

@@ -1,13 +1,22 @@
+#Calling `git smart-pull` will fetch remote tracked changes
+#and reapply your work on top of it. It's like a much, much
+#smarter version of `git pull --rebase`.
+#
+#For some background as to why this is needed, see [my blog
+#post about the perils of rebasing merge commits](https://gist.github.com/591209)
+#
+#This is how it works:
+
 GitSmart.register 'smart-pull' do |repo, args|
-  # Let's begin!
+  #Let's begin!
   branch = repo.current_branch
   start "Starting: smart-pull on branch '#{branch}'"
 
-  # Let's not have any arguments, fellas.
+  #Let's not have any arguments, fellas.
   warn "Ignoring arguments: #{args.inspect}" if !args.empty?
 
-  # Try grabbing the tracking remote from the config. If it doesn't exist,
-  # notify the user and choose 'origin'
+  #Try grabbing the tracking remote from the config. If it doesn't exist,
+  #notify the user and default to 'origin'
   tracking_remote = repo.tracking_remote ||
     note("No tracking remote configured, assuming 'origin'") ||
     'origin'
@@ -16,58 +25,77 @@ GitSmart.register 'smart-pull' do |repo, args|
   # but generally that's a good thing. This is the only communication we need to do with the server.
   repo.fetch!(tracking_remote)
 
-  # Try grabbing the tracking branch from the config. If it doesn't exist,
-  # notify the user and choose the branch of the same name
+  #Try grabbing the tracking branch from the config. If it doesn't exist,
+  #notify the user and choose the branch of the same name
   tracking_branch = repo.tracking_branch ||
     note("No tracking branch configured, assuming '#{branch}'") ||
     branch
 
-  # Check the upstream branch exists
+  #Check the specified upstream branch exists. Fail if it doesn't.
   upstream_branch = "#{tracking_remote}/#{tracking_branch}"
   failure("Upstream branch '#{upstream_branch}' doesn't exist!") if !repo.exists?(upstream_branch)
 
+  #Grab the SHAs of the commits we'll be working with.
   head = repo.sha('HEAD')
   remote = repo.sha(upstream_branch)
 
+  #If both HEAD and our upstream_branch resolve to the same SHA, there's nothing to do!
   if head == remote
     puts "Neither your local branch '#{branch}', nor the remote branch '#{upstream_branch}' have moved on."
     success "Already up-to-date"
   else
+    #Find out where the two branches diverged using merge-base. It's what git
+    #uses internally.
     merge_base = repo.merge_base(head, remote)
 
+    #By comparing the merge_base to both HEAD and the remote, we can
+    #determine whether both or only one have moved on.
+    #If the remote hasn't changed, we're already up to date, so there's nothing
+    #to pull.
     if merge_base == remote
       puts "Remote branch '#{upstream_branch}' has not moved on."
       success "Already up-to-date"
     else
+      #If the remote _has_ moved on, we actually have some work to do:
+      #
+      #First, report how many commits are new on remote. Because that's useful information.
       new_commits_on_remote = repo.rev_list(merge_base, remote)
       is_are, s_or_not = (new_commits_on_remote.length == 1) ? ['is', ''] : ['are', 's']
-      note "There #{is_are} #{new_commits_on_remote.length} new commit#{s_or_not} on master."
+      note "There #{is_are} #{new_commits_on_remote.length} new commit#{s_or_not} on '#{upstream_branch}'."
 
+      #Next, detect if there are local changes and stash them.
       stash_required = repo.dirty?
       if stash_required
         note "Working directory dirty. Stashing..."
         repo.stash!
-      else
-        puts "No uncommitted changes, no need to stash."
       end
 
       success_messages = []
 
+      #Then, bring the local branch up to date.
+      #
+      #If our local branch hasn't moved on, that's easy - we just need to fast-forward.
       if merge_base == head
         puts "Local branch '#{branch}' has not moved on. Fast-forwarding..."
         repo.fast_forward!(upstream_branch)
         success_messages << "Fast forwarded from #{head[0,7]} to #{remote[0,7]}"
       else
+        #If our local branch has new commits, we need to rebase them on top of master.
+        #
+        #When we rebase, we use `git rebase -p`, which attempts to recreate merges
+        #instead of ignoring them. For a description as to why, see my [blog post]((https://gist.github.com/591209).
         note "Both local and remote branches have moved on. Branch 'master' needs to be rebased onto 'origin/master'"
         repo.rebase_preserving_merges!(upstream_branch)
         success_messages << "HEAD moved from #{head[0,7]} to #{repo.sha('HEAD')[0,7]}."
       end
 
+      #If we stashed before, pop now.
       if stash_required
         note "Reapplying local changes..."
         repo.stash_pop!
       end
 
+      #Display a nice completion message in large, friendly letters.
       success ["All good.", *success_messages].join(" ")
     end
 

data/lib/git-smart/git_repo.rb

@@ -22,7 +22,9 @@ class GitRepo
   def tracking_branch
     key   = "branch.#{current_branch}.merge"
     value = config(key)
-    if value =~ /^refs\/heads\/(.*)$/
+    if value.nil?
+      value
+    elsif value =~ /^refs\/heads\/(.*)$/
       $1
     else
       raise GitSmart::UnexpectedOutput.new("Expected the config of '#{key}' to be /refs/heads/branchname, got '#{value}'")
@@ -30,7 +32,7 @@ class GitRepo
   end
 
   def fetch!(remote)
-    log_git('fetch', remote)
+    git!('fetch', remote)
   end
 
   def merge_base(ref_a, ref_b)
@@ -61,6 +63,7 @@ class GitRepo
           when /^M/; :modified
           when /^A/; :added
           when /^\?\?/; :untracked
+          when /^UU/; :conflicted
           else raise GitSmart::UnexpectedOutput.new("Expected the output of git status to only have lines starting with A,M, or ??. Got: \n#{raw_status}")
         end
       }
@@ -71,19 +74,19 @@ class GitRepo
   end
 
   def fast_forward!(upstream)
-    log_git('merge', '--ff-only', upstream)
+    git!('merge', '--ff-only', upstream)
   end
 
   def stash!
-    log_git('stash')
+    git!('stash')
   end
 
   def stash_pop!
-    log_git('stash', 'pop')
+    git!('stash', 'pop')
   end
 
   def rebase_preserving_merges!(upstream)
-    log_git('rebase', '-p', upstream)
+    git!('rebase', '-p', upstream)
   end
 
   def log(nr)
@@ -94,16 +97,22 @@ class GitRepo
     log(nr).map(&:last)
   end
 
+  def merge_no_ff!(target)
+    git!('merge', '--no-ff', target)
+  end
+
   # helper methods, left public in case other commands want to use them directly
 
   def git(*args)
-    Dir.chdir(@dir) { SafeShell.execute('git', *args) }
+    output = exec_git(*args)
+    $?.success? ? output : ''
   end
 
-  def log_git(*args)
+  def git!(*args)
     puts "Executing: #{['git', *args].join(" ")}"
-    output = git(*args)
-    puts output.split("\n").map { |l| "  #{l}" }
+    output = exec_git(*args)
+    to_display = output.split("\n").map { |l| "  #{l}" }.join("\n")
+    $?.success? ? puts(to_display) : raise(GitSmart::UnexpectedOutput.new(to_display))
     output
   end
 
@@ -111,4 +120,12 @@ class GitRepo
     remote = git('config', name).chomp
     remote.empty? ? nil : remote
   end
+
+  private
+
+  def exec_git(*args)
+    Dir.chdir(@dir) {
+      SafeShell.execute('git', *args)
+    }
+  end
 end

data/spec/smart-merge_failures_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'fileutils'
+
+describe 'smart-merge with failures' do
+  def local_dir;  WORKING_DIR + '/local';  end
+
+  before :each do
+    %x[
+      cd #{WORKING_DIR}
+        mkdir local
+        cd local
+          git init
+          echo -e 'one\ntwo\nthree\nfour\n' > README
+          mkdir lib
+          echo 'puts "pro hax"' > lib/codes.rb
+          git add .
+          git commit -m 'first'
+    ]
+  end
+
+  context "with conflicting changes on master and newbranch" do
+    before :each do
+      %x[
+        cd #{local_dir}
+          git checkout -b newbranch 2> /dev/null
+          echo 'one\nnewbranch changes\nfour\n' > README
+          git commit -am 'newbranch_commit'
+
+          git checkout master 2> /dev/null
+
+          echo 'one\nmaster changes\nfour\n' > README
+          git commit -am 'master_commit'
+      ]
+    end
+
+    it "should report the failure and give instructions to the user" do
+      out = run_command(local_dir, 'smart-merge', 'newbranch')
+      local_dir.should have_git_status(:conflicted => ['README'])
+      out.should_not report("All good")
+      out.should report("Executing: git merge --no-ff newbranch")
+      out.should report("CONFLICT (content): Merge conflict in README")
+      out.should report("Automatic merge failed; fix conflicts and then commit the result.")
+    end
+  end
+end

data/spec/smart-merge_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'fileutils'
+
+describe 'smart-merge' do
+  def local_dir;  WORKING_DIR + '/local';  end
+
+  before :each do
+    %x[
+      cd #{WORKING_DIR}
+        mkdir local
+        cd local
+          git init
+          echo 'hurr durr' > README
+          mkdir lib
+          echo 'puts "pro hax"' > lib/codes.rb
+          git add .
+          git commit -m 'first'
+    ]
+  end
+
+  it "should require an argument" do
+    out = run_command(local_dir, 'smart-merge')
+    out.should report("Usage: git smart-merge ref")
+  end
+
+  it "should require a valid branch" do
+    out = run_command(local_dir, 'smart-merge', 'foo')
+    out.should report("Branch to merge 'foo' not recognised by git!")
+  end
+
+  it "should report nothing to do if the branch hasn't moved on" do
+    %x[
+      cd #{local_dir}
+      git branch unmoved
+    ]
+    out = run_command(local_dir, 'smart-merge', 'unmoved')
+    out.should report("Branch 'unmoved' has no new commits. Nothing to merge in.")
+    out.should report("Already up-to-date.")
+  end
+
+  context "with local changes to newbranch" do
+    before :each do
+      %x[
+        cd #{local_dir}
+          git checkout -b newbranch 2> /dev/null
+          echo 'moar things!' >> README
+          echo 'puts "moar code!"' >> lib/moar.rb
+          git add .
+          git commit -m 'moar'
+
+          git checkout master 2> /dev/null
+      ]
+    end
+
+    it "should merge --no-ff, despite the branch being fast-forwardable" do
+      out = run_command(local_dir, 'smart-merge', 'newbranch')
+      out.should report("Branch 'newbranch' has diverged by 1 commit. Merging in.")
+      out.should report("* Branch 'master' has not moved on since 'newbranch' diverged. Running with --no-ff anyway, since a fast-forward is unexpected behaviour.")
+      out.should report("Executing: git merge --no-ff newbranch")
+      out.should report("2 files changed, 2 insertions(+), 0 deletions(-)")
+      out.should report(/All good\. Created merge commit [\w]{7}\./)
+    end
+
+    context "and changes on master" do
+      before :each do
+        %x[
+          cd #{local_dir}
+            echo "puts 'moar codes too!'" >> lib/codes.rb
+            git add .
+            git commit -m 'changes on master'
+        ]
+      end
+
+      it "should merge in ok" do
+        out = run_command(local_dir, 'smart-merge', 'newbranch')
+        out.should report("Branch 'newbranch' has diverged by 1 commit. Merging in.")
+        out.should report("Branch 'master' has 1 new commit since 'newbranch' diverged.")
+        out.should report("Executing: git merge --no-ff newbranch")
+        out.should report("2 files changed, 2 insertions(+), 0 deletions(-)")
+        out.should report(/All good\. Created merge commit [\w]{7}\./)
+      end
+
+      it "should stash then merge if working tree is dirty" do
+        %x[
+          cd #{local_dir}
+            echo "i am nub" > noob
+            echo "puts 'moar codes too!'" >> lib/codes.rb
+            git add noob
+        ]
+        out = run_command(local_dir, 'smart-merge', 'newbranch')
+        out.should report("Executing: git stash")
+        out.should report("Executing: git merge --no-ff newbranch")
+        out.should report("2 files changed, 2 insertions(+), 0 deletions(-)")
+        out.should report("Reapplying local changes...")
+        out.should report("Executing: git stash pop")
+        out.should report(/All good\. Created merge commit [\w]{7}\./)
+      end
+    end
+  end
+end