git-smart-ruby-3 0.0.1

data/lib/git-smart/git_repo.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+require 'yaml'
+require 'pathname'
+
+class GitRepo
+  def initialize(dir)
+    @dir = dir
+    unless File.directory?(git_dir)
+      raise GitSmart::RunFailed.new(
+        <<-MSG.gsub(/^\s+/, '')
+        You need to run this from within a Git directory.
+        Current working directory: #{File.expand_path(dir)}
+        Expected .git directory: #{git_dir}
+        MSG
+      )
+    end
+  end
+
+  def git_dir
+    gitdir = Pathname.new(@dir).join('.git')
+
+    unless File.exist?(gitdir)
+      @dir = git('rev-parse', '--show-toplevel').chomp
+      gitdir = Pathname.new(@dir).join('.git') unless @dir.empty?
+    end
+
+    if File.file?(gitdir)
+      submodule = YAML.load_file(gitdir)
+      gitdir = Pathname.new(@dir).join(submodule['gitdir']).to_path
+    end
+
+    gitdir
+  end
+
+  def current_branch
+    head_file = File.join(git_dir, 'HEAD')
+    File.read(head_file).strip.sub(%r(^.*refs/heads/), '')
+  end
+
+  def sha(ref)
+    sha = git('rev-parse', ref).chomp
+    sha.empty? ? nil : sha
+  end
+
+  def tracking_remote
+    config("branch.#{current_branch}.remote")
+  end
+
+  def tracking_branch
+    key   = "branch.#{current_branch}.merge"
+    value = config(key)
+    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}'")
+    end
+  end
+
+  def fetch!(remote)
+    git!('fetch', remote)
+  end
+
+  def merge_base(ref_a, ref_b)
+    git('merge-base', ref_a, ref_b).chomp
+  end
+
+  def exists?(ref)
+    git('rev-parse', ref)
+    $?.success?
+  end
+
+  def rev_list(ref_a, ref_b)
+    git('rev-list', "#{ref_a}..#{ref_b}").split("\n")
+  end
+
+  def raw_status
+    git('status', '-s')
+  end
+
+  def status
+    raw_status.
+      split("\n").
+      map { |l| l.split(" ") }.
+      group_by(&:first).
+      map_values { |lines| lines.map(&:last) }.
+      map_keys { |status|
+        case status
+          when /^[^ ]*M/; :modified
+          when /^[^ ]*A/; :added
+          when /^[^ ]*D/; :deleted
+          when /^[^ ]*\?\?/; :untracked
+          when /^[^ ]*UU/; :conflicted
+          else raise GitSmart::UnexpectedOutput.new("Expected the output of git status to only have lines starting with A, M, D, UU, or ??. Got: \n#{raw_status}")
+        end
+      }
+  end
+
+  def dirty?
+    status.any? { |k,v| k != :untracked && v.any? }
+  end
+
+  def fast_forward!(upstream)
+    git!('merge', '--ff-only', upstream)
+  end
+
+  def stash!
+    git!('stash')
+  end
+
+  def stash_pop!
+    git!('stash', 'pop')
+  end
+
+  def rebase_preserving_merges!(upstream)
+    git!('rebase', '--rebase-merges', upstream)
+  end
+
+  def read_log(nr)
+    git('log', '--oneline', '-n', nr.to_s).split("\n").map { |l| l.split(" ",2) }
+  end
+
+  def last_commit_messages(nr)
+    read_log(nr).map(&:last)
+  end
+
+  def log_to_shell(*args)
+    git_shell('log', *args)
+  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)
+    output = exec_git(*args)
+    $?.success? ? output : ''
+  end
+
+  def git!(*args)
+    puts "Executing: #{['git', *args].join(" ")}"
+    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
+
+  def git_shell(*args)
+    puts "Executing: #{['git', *args].join(" ")}"
+    Dir.chdir(@dir) {
+      system('git', *args)
+    }
+  end
+
+  def config(name)
+    remote = git('config', name).chomp
+    remote.empty? ? nil : remote
+  end
+
+  private
+
+  def exec_git(*args)
+    return if @dir.empty?
+    Dir.chdir(@dir) {
+      SafeShell.execute('git', *args)
+    }
+  end
+end

data/lib/git-smart/git_smart.rb

@@ -0,0 +1,28 @@
+class GitSmart
+  def self.run(code, args)
+    lambda = commands[code]
+    if lambda
+      begin
+        lambda.call(args)
+      rescue GitSmart::Exception => e
+        if e.message && !e.message.empty?
+          puts e.message.red
+        end
+      end
+    else
+      puts "No command #{code.inspect} defined! Available commands are #{commands.keys.sort.inspect}"
+    end
+  end
+
+  # Used like this:
+  # GitSmart.register 'my-command' do |repo, args|
+  def self.register(code, &blk)
+    commands[code] = lambda { |args|
+      ExecutionContext.new.instance_exec(GitRepo.new("."), args, &blk)
+    }
+  end
+
+  def self.commands
+    @commands ||= {}
+  end
+end

data/lib/git-smart/safe_shell.rb

@@ -0,0 +1,21 @@
+module SafeShell
+  def self.execute(command, *args)
+    read_end, write_end = IO.pipe
+    pid = fork do
+      read_end.close
+      STDOUT.reopen(write_end)
+      STDERR.reopen(write_end)
+      exec(command, *args)
+    end
+    write_end.close
+    output = read_end.read
+    Process.waitpid(pid)
+    read_end.close
+    output
+  end
+
+  def self.execute?(*args)
+    execute(*args)
+    $?.success?
+  end
+end

data/lib/git-smart-ruby-3.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+class GitSmart
+end
+
+%w[core_ext git-smart commands].each { |dir|
+  Dir.glob(File.join(File.dirname(__FILE__), dir, '**', '*.rb')) { |f| require f }
+}

data/spec/smart-merge_failures_spec.rb

@@ -0,0 +1,49 @@
+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
+          git config --local user.name 'Maxwell Smart'
+          git config --local user.email 'agent86@control.gov'
+          git config --local core.pager 'cat'
+          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,104 @@
+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
+          git config --local user.name 'Maxwell Smart'
+          git config --local user.email 'agent86@control.gov'
+          git config --local core.pager 'cat'
+          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

data/spec/smart-pull_spec.rb

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'fileutils'
+
+describe 'smart-pull' do
+  def local_dir;  WORKING_DIR + '/local';  end
+  def remote_dir; WORKING_DIR + '/remote'; end
+
+  before :each do
+    %x[
+      cd #{WORKING_DIR}
+        mkdir remote
+        cd remote
+          git init
+          git config --local user.name 'Maxwell Smart'
+          git config --local user.email 'agent86@control.gov'
+          git config --local core.pager 'cat'
+          echo 'hurr durr' > README
+          mkdir lib
+          echo 'puts "pro hax"' > lib/codes.rb
+          git add .
+          git commit -m 'first'
+        cd ..
+        git clone remote/.git local
+        cd local
+          git config --local user.name 'Agent 99'
+          git config --local user.email 'agent99@control.gov'
+          git config --local core.pager 'cat'
+    ]
+  end
+
+  it "should tell us there's nothing to do" do
+    out = run_command(local_dir, 'smart-pull')
+    out.should report("Executing: git fetch origin")
+    out.should report("Neither your local branch 'master', nor the remote branch 'origin/master' have moved on.")
+    out.should report("Already up-to-date")
+  end
+
+  context "with only local changes" do
+    before :each do
+      %x[
+        cd #{local_dir}
+          echo 'moar things!' >> README
+          echo 'puts "moar code!"' >> lib/moar.rb
+          git add .
+          git commit -m 'moar'
+      ]
+    end
+
+    it "should report that no remote changes were found" do
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Executing: git fetch origin")
+      out.should report("Remote branch 'origin/master' has not moved on.")
+      out.should report("You have 1 new commit on 'master'.")
+      out.should report("Already up-to-date")
+    end
+  end
+
+  context "with only remote changes" do
+    before :each do
+      %x[
+        cd #{remote_dir}
+          echo 'changed on the server!' >> README
+          git add .
+          git commit -m 'upstream changes'
+      ]
+    end
+
+    it "should fast-forward" do
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Executing: git fetch origin")
+      out.should report(/master +-> +origin\/master/)
+      out.should report("There is 1 new commit on 'origin/master'.")
+      out.should report("Local branch 'master' has not moved on. Fast-forwarding.")
+      out.should report("Executing: git merge --ff-only origin/master")
+      out.should report(/Updating [^\.]+..[^\.]+/)
+      out.should report(/1 files? changed, 1 insertions?\(\+\)(, 0 deletions\(-\))?$/)
+    end
+
+    it "should not stash before fast-forwarding if untracked files are present" do
+      %x[
+        cd #{local_dir}
+          echo "i am nub" > noob
+      ]
+      local_dir.should have_git_status({:untracked => ['noob']})
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Executing: git merge --ff-only origin/master")
+      out.should report(/1 files? changed, 1 insertions?\(\+\)(, 0 deletions\(-\))?$/)
+      local_dir.should have_git_status({:untracked => ['noob']})
+    end
+
+    it "should stash, fast forward, pop if there are local changes" do
+      %x[
+        cd #{local_dir}
+          echo "i am nub" > noob
+          echo "puts 'moar codes too!'" >> lib/codes.rb
+          git add noob
+      ]
+      local_dir.should have_git_status({:added => ['noob'], :modified => ['lib/codes.rb']})
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Working directory dirty. Stashing...")
+      out.should report("Executing: git stash")
+      out.should report("Executing: git merge --ff-only origin/master")
+      out.should report(/1 files? changed, 1 insertions?\(\+\)(, 0 deletions\(-\))?$/)
+      out.should report("Reapplying local changes...")
+      out.should report("Executing: git stash pop")
+      local_dir.should have_git_status({:added => ['noob'], :modified => ['lib/codes.rb']})
+    end
+  end
+
+  context "with diverged branches" do
+    before :each do
+      %x[
+        cd #{remote_dir}
+          echo 'changed on the server!' >> README
+          git add .
+          git commit -m 'upstream changes'
+
+        cd #{local_dir}
+          echo "puts 'moar codes too!'" >> lib/codes.rb
+          git add .
+          git commit -m 'local changes'
+      ]
+    end
+
+    it "should rebase" do
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Executing: git fetch origin")
+      out.should report(/master +-> +origin\/master/)
+      out.should report("There is 1 new commit on 'origin/master'.")
+      out.should report("You have 1 new commit on 'master'.")
+      out.should report("Both local and remote branches have moved on. Branch 'master' needs to be rebased onto 'origin/master'")
+      out.should report("Executing: git rebase -p origin/master")
+      out.should report("Successfully rebased and updated refs/heads/master.")
+      local_dir.should have_last_few_commits(['local changes', 'upstream changes', 'first'])
+    end
+
+    it "should not stash before rebasing if untracked files are present" do
+      %x[
+        cd #{local_dir}
+          echo "i am nub" > noob
+      ]
+      local_dir.should have_git_status({:untracked => ['noob']})
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Executing: git rebase -p origin/master")
+      out.should report("Successfully rebased and updated refs/heads/master.")
+      local_dir.should have_git_status({:untracked => ['noob']})
+      local_dir.should have_last_few_commits(['local changes', 'upstream changes', 'first'])
+    end
+
+    it "should stash, rebase, pop if there are local uncommitted changes" do
+      %x[
+        cd #{local_dir}
+          echo "i am nub" > noob
+          echo "puts 'moar codes too!'" >> lib/codes.rb
+          git add noob
+      ]
+      local_dir.should have_git_status({:added => ['noob'], :modified => ['lib/codes.rb']})
+      out = run_command(local_dir, 'smart-pull')
+      out.should report("Working directory dirty. Stashing...")
+      out.should report("Executing: git stash")
+      out.should report("Executing: git rebase -p origin/master")
+      out.should report("Successfully rebased and updated refs/heads/master.")
+      local_dir.should have_git_status({:added => ['noob'], :modified => ['lib/codes.rb']})
+      local_dir.should have_last_few_commits(['local changes', 'upstream changes', 'first'])
+    end
+  end
+
+  context 'with a submodule' do
+    before do
+      %x[
+      cd #{WORKING_DIR}
+        mkdir submodule
+        cd submodule
+          git init
+          git config --local user.name 'The Chief'
+          git config --local user.email 'agentq@control.gov'
+          git config --local core.pager 'cat'
+          echo 'Unusual, but effective.' > README
+          git add .
+          git commit -m 'first'
+        cd ..
+        cd local
+          git submodule add "${PWD}/../submodule/.git" submodule
+          git commit -am 'Add submodule'
+      ]
+    end
+    let(:submodule_dir) { local_dir + '/submodule' }
+
+    it 'can smart-pull the repo containing the submodule' do
+      out = run_command(local_dir, 'smart-pull')
+      out.should report('Executing: git fetch origin')
+      out.should report("Remote branch 'origin/master' has not moved on.")
+      out.should report("You have 1 new commit on 'master'.")
+    end
+
+    it 'can smart-pull the submodule' do
+      out = run_command(submodule_dir, 'smart-pull')
+      out.should report('Executing: git fetch origin')
+      out.should report("Neither your local branch 'master', nor the remote branch 'origin/master' have moved on.")
+      out.should report('Already up-to-date')
+    end
+  end
+
+  context 'outside of a repo' do
+    it 'should report a meaningful error' do
+      Dir.mktmpdir do |non_repo_dir|
+        out = run_command(non_repo_dir, 'smart-pull')
+        out.should report 'You need to run this from within a Git directory'
+        out.should report 'Current working directory: '
+        out.should report 'Expected .git directory: '
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+require 'rspec'
+require 'tmpdir'
+
+require File.dirname(__FILE__) + '/../lib/git-smart-ruby-3'
+
+WORKING_DIR = File.dirname(__FILE__) + '/working'
+
+RSpec.configure do |config|
+  config.before :each do
+    FileUtils.rm_rf WORKING_DIR
+    FileUtils.mkdir_p WORKING_DIR
+  end
+
+  config.after :each do
+    FileUtils.rm_rf WORKING_DIR
+  end
+end
+
+def run_command(dir, command, *args)
+  require 'stringio'
+  $stdout = stdout = StringIO.new
+
+  Dir.chdir(dir) { GitSmart.run(command, args) }
+
+  $stdout = STDOUT
+  stdout.string.split("\n")
+end
+
+RSpec::Matchers.define :report do |expected|
+  failure_message_for_should do |actual|
+    "expected to see #{expected.inspect}, got \n\n#{actual.map { |line| "  #{line}" }.join("\n")}"
+  end
+  failure_message_for_should_not do |actual|
+    "expected not to see #{expected.inspect} in \n\n#{actual.map { |line| "  #{line}" }.join("\n")}"
+  end
+  match do |actual|
+    actual.any? { |line| line[expected] }
+  end
+end
+
+
+RSpec::Matchers.define :have_git_status do |expected|
+  failure_message_for_should do |dir|
+    "expected '#{dir}' to have git status of #{expected.inspect}, got #{GitRepo.new(dir).status.inspect}"
+  end
+  failure_message_for_should_not do |actual|
+    "expected '#{dir}' to not have git status of #{expected.inspect}, got #{GitRepo.new(dir).status.inspect}"
+  end
+  match do |dir|
+    GitRepo.new(dir).status == expected
+  end
+end
+
+
+RSpec::Matchers.define :have_last_few_commits do |expected|
+  failure_message_for_should do |dir|
+    "expected '#{dir}' to have last few commits of #{expected.inspect}, got #{GitRepo.new(dir).last_commit_messages(expected.length).inspect}"
+  end
+  failure_message_for_should_not do |actual|
+    "expected '#{dir}' to not have git status of #{expected.inspect}, got #{GitRepo.new(dir).last_commit_messages(expected.length).inspect}"
+  end
+  match do |dir|
+    GitRepo.new(dir).last_commit_messages(expected.length) == expected
+  end
+end