git-smart 0.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'colorize'
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "rcov", ">= 0"
+  gem 'ruby-debug'
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    columnize (0.3.2)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    linecache (0.43)
+    rake (0.8.7)
+    rcov (0.9.8)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  colorize
+  jeweler (~> 1.5.2)
+  rcov
+  rspec (~> 2.3.0)
+  ruby-debug

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Glen Maddern
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# git-smart
+
+Adds some additional git commands to add some smarts to your workflow. These commands follow a few guidelines:
+
+0. It should do the 'right thing' in all situations - an inexperienced git user should be guided away from making simple mistakes.
+0. It should make every attempt to explain to the user what decisions it has made, and why.
+0. All git commands that modify the repository should be shown to the user - hopefully this helps the user eventually learn the underlying git commands, and when they're relevant.
+0. All git commands, destructive or not, and their output should be shown to the user with the -v/--verbose flag.
+
+## git-smart-pull
+
+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:
+
+0. First, determine which remote branch to update from. Use branch tracking config if present, otherwise default to a remote of 'origin' and the same branch name. E.g. 'branchX', by default, tracks 'origin/branchX'.
+0. Fetch the remote.
+0. Determine what needs to be done:
+  - If the remote is a parent of HEAD, there's nothing to do.
+  - If HEAD is a parent of the remote, you simply need to reapply any working changes to the new HEAD. Stash, fast-forward, stash pop.
+  - If HEAD and the remote have diverged:
+    0. stash
+    0. rebase -p onto the remote
+    0. stash pop
+    0. update ORIG\_HEAD to be the previous local HEAD, as expected (rebase -p doesn't set ORIG\_HEAD correctly)
+0. Output a summary of what just happened, as well as any new or updated branches that came down with the last fetch.
+0. Output a big, green GIT UP GOOD or red GIT UP BAD, depending on how things went.
+
+# Contributing to git-smart
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+# Copyright
+
+Copyright (c) 2011 Glen Maddern. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "git-smart"
+  gem.homepage = "http://github.com/geelen/git-smart"
+  gem.license = "MIT"
+  gem.summary = %Q{Add some smarts to your git workflow}
+  gem.description = %Q{Installs some additional 'smart' git commands, like `git smart-pull`.}
+  gem.email = "glenmaddern@gmail.com"
+  gem.authors = ["Glen Maddern"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "git-smart #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/git-smart

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+
+class GitSmartBinary
+  USAGE = %Q{Usage:
+    git-smart list                          List all the git commands that can be installed
+    git-smart install --all                 Install all git commands
+    git-smart install command [command]     Install these git commands
+  }
+
+  def initialize
+    # If this was called through a symlink, follow it and include the lib/git-smart.rb file
+    require File.expand_path(
+      File.join(
+        File.dirname(File.expand_path(
+          File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+        )),
+        '../lib/git-smart'
+      )
+    )
+  end
+
+  def list
+    puts "These commands available to install:"
+    puts GitSmart.commands.keys.map { |c| "  git-smart install " + c }.join("\n")
+    puts "\nOr install everything with: git-smart install --all"
+  end
+
+  def install(args)
+    cmds = if args.include? '--all'
+             GitSmart.commands.keys
+           else
+             args
+           end
+    install_dir = File.dirname(`which git`)
+    puts "Installing #{cmds.join(', ')} to #{install_dir}:"
+    cmds.each { |cmd|
+      filename = "#{install_dir}/git-#{cmd}"
+      File.open(filename, 'w') { |out|
+        out.puts %Q{#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'git-smart'
+
+GitSmart.run(#{cmd}, ARGV)
+}
+      }
+      `chmod a+x #{filename}`
+      puts "Wrote #{filename}"
+    }
+  end
+end
+
+case ARGV.shift
+  when 'list': GitSmartBinary.new.list
+  when 'install': GitSmartBinary.new.install(ARGV)
+  else puts GitSmartBinary::USAGE
+end

data/lib/commands/smart-pull.rb

@@ -0,0 +1,69 @@
+GitSmart.register 'smart-pull' do |repo, args|
+  # Let's begin!
+  branch = repo.current_branch
+  start "Starting: smart-pull on branch '#{branch}'"
+
+  # 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'
+  tracking_remote = repo.tracking_remote ||
+    note("No tracking remote configured, assuming 'origin'") ||
+    'origin'
+
+  # Fetch the remote. This pulls down all new commits from the server, not just our branch,
+  # but generally that's a good thing. This is the only communication we need to do with the server.
+  puts_with_done("Fetching '#{tracking_remote}'") { 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
+  tracking_branch = repo.tracking_branch ||
+    note("No tracking branch configured, assuming '#{branch}'") ||
+    branch
+
+  # Check the upstream branch exists
+  upstream_branch = "#{tracking_remote}/#{tracking_branch}"
+  failure("Upstream branch '#{upstream_branch}' doesn't exist!") if !repo.exists?(upstream_branch)
+
+  head = repo.sha('HEAD')
+  remote = repo.sha(upstream_branch)
+
+  if head == remote
+    puts "Neither your local branch '#{branch}', nor the remote branch '#{upstream_branch}' have moved on."
+    success "Already up-to-date"
+  else
+    merge_base = repo.merge_base(head, remote)
+
+    if merge_base == remote
+      puts "Remote branch '#{upstream_branch}' has not moved on."
+      success "Already up-to-date"
+    else
+      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."
+
+      stash_required = repo.dirty?
+      if stash_required
+        note "Working directory dirty. Stashing..."
+        repo.stash!
+      else
+        puts "No uncommitted changes, no need to stash."
+      end
+
+      if merge_base == head
+        puts "Local branch '#{branch}' has not moved on. Fast-forwarding..."
+        repo.fast_forward!(upstream_branch)
+      else
+        note "Both local and remote branches have moved on. Branch 'master' needs to be rebased onto 'origin/master'"
+        repo.rebase_preserving_merges!(upstream_branch)
+      end
+
+      if stash_required
+        note "Reapplying local changes..."
+        repo.stash_pop!
+      end
+    end
+
+  end
+end

data/lib/core_ext/array.rb

@@ -0,0 +1,9 @@
+class Array
+  def group_by(&blk)
+    Hash.new { |h,k| h[k] = [] }.tap do |hash|
+      each do |element|
+        hash[blk.call(element)] << element
+      end
+    end
+  end
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def map_keys &blk
+    map_keys_with_values { |k,v| blk.call(k) }
+  end
+
+  def map_keys_with_values &blk
+    result = {}
+    each { |k,v| result[blk.call(k,v)] = v}
+    result
+  end
+
+  def map_values &blk
+    map_values_with_keys { |k,v| blk.call(v) }
+  end
+
+  def map_values_with_keys &blk
+    result = {}
+    each { |k,v| result[k] = blk.call(k,v)}
+    result
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,8 @@
+class Object
+  def tapp(prefix = nil, &block)
+    block ||= lambda {|x| x }
+    str = if block[self].is_a? String then block[self] else block[self].inspect end
+    puts [prefix, str].compact.join(": ")
+    self
+  end
+end

data/lib/git-smart.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/lib/git-smart/exceptions.rb

@@ -0,0 +1,2 @@
+class GitSmart::RunFailed < Exception; end
+class GitSmart::UnexpectedOutput < Exception; end

data/lib/git-smart/execution_context.rb

@@ -0,0 +1,39 @@
+# The context that commands get executed within. Used for defining and scoping helper methods.
+
+class ExecutionContext
+  def initialize
+    require 'colorize'
+  end
+
+  def start msg
+    puts "- #{msg} -".green
+  end
+
+  def note msg
+    puts "* #{msg}"
+  end
+
+  def warn msg
+    puts msg.red
+  end
+
+  def puts_with_done msg, &blk
+    print "#{msg}..."
+    blk.call
+    puts "done."
+  end
+
+  def success msg
+    puts big_message(msg).green
+  end
+
+  def failure msg
+    puts big_message(msg).red
+    raise GitSmart::RunFailed
+  end
+
+  def big_message msg
+    spacer_line = (" " + "-" * (msg.length + 20) + " ")
+    [spacer_line, "|" + " " * 10 + msg + " " * 10 + "|", spacer_line].join("\n")
+  end
+end

data/lib/git-smart/git_repo.rb

@@ -0,0 +1,111 @@
+class GitRepo
+  def initialize(dir)
+    @dir = dir
+  end
+
+  def current_branch
+    File.read(File.join(@dir, ".git", "HEAD")).strip.sub(/^.*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 =~ /^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 /^\?\?/: :untracked
+          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
+      }
+  end
+
+  def dirty?
+    status.any? { |k,v| k != :untracked && v.any? }
+  end
+
+  def fast_forward!(upstream)
+    log_git('merge', '--ff-only', upstream)
+  end
+
+  def stash!
+    log_git('stash')
+  end
+
+  def stash_pop!
+    log_git('stash', 'pop')
+  end
+
+  def rebase_preserving_merges!(upstream)
+    log_git('rebase', '-p', upstream)
+  end
+
+  def log(nr)
+    git('log', '--oneline', '-n', nr.to_s).split("\n").map { |l| l.split(" ",2) }
+  end
+
+  def log_commit_messages(nr)
+    log(nr).map(&:last)
+  end
+
+  # helper methods, left public in case other commands want to use them directly
+
+  def git(*args)
+    Dir.chdir(@dir) { SafeShell.execute('git', *args) }
+  end
+
+  def log_git(*args)
+    puts "Executing: #{['git', *args].join(" ")}"
+    output = git(*args)
+    puts output.split("\n").map { |l| "  #{l}" }
+    output
+  end
+
+  def config(name)
+    remote = git('config', name).chomp
+    remote.empty? ? nil : remote
+  end
+end

data/lib/git-smart/git_smart.rb

@@ -0,0 +1,25 @@
+class GitSmart
+  def self.run(code, args)
+    lambda = commands[code]
+    if lambda
+      begin
+        lambda.call(args)
+      rescue GitSmart::RunFailed
+      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/spec/smart-pull_spec.rb

@@ -0,0 +1,161 @@
+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
+          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
+    ]
+  end
+
+  it "should tell us there's nothing to do" do
+    out = run_command(local_dir, 'smart-pull')
+    out.should report("Fetching '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("Fetching 'origin'")
+      out.should report("Remote branch 'origin/master' has not moved on.")
+      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("Fetching 'origin'")
+      out.should report("There is 1 new commit on master.")
+      out.should report("No uncommitted changes, no need to stash.")
+      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("No uncommitted changes, no need to stash.")
+      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("Fetching 'origin'")
+      out.should report("There is 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("No uncommitted changes, no need to 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({: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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+require 'ruby-debug'
+require 'rspec'
+
+require File.dirname(__FILE__) + '/../lib/git-smart'
+
+WORKING_DIR = File.dirname(__FILE__) + '/working'
+
+RSpec.configure do |config|
+  config.before :each do
+    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).log_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).log_commit_messages(expected.length).inspect}"
+  end
+  match do |dir|
+    GitRepo.new(dir).log_commit_messages(expected.length) == expected
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification 
+name: git-smart
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Glen Maddern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-04 00:00:00 +11:00
+default_executable: git-smart
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: colorize
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rspec
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rcov
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: ruby-debug
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: bundler
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id006
+description: Installs some additional 'smart' git commands, like `git smart-pull`.
+email: glenmaddern@gmail.com
+executables: 
+- git-smart
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/git-smart
+- lib/commands/smart-pull.rb
+- lib/core_ext/array.rb
+- lib/core_ext/hash.rb
+- lib/core_ext/object.rb
+- lib/git-smart.rb
+- lib/git-smart/exceptions.rb
+- lib/git-smart/execution_context.rb
+- lib/git-smart/git_repo.rb
+- lib/git-smart/git_smart.rb
+- lib/git-smart/safe_shell.rb
+- spec/smart-pull_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/geelen/git-smart
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Add some smarts to your git workflow
+test_files: 
+- spec/smart-pull_spec.rb
+- spec/spec_helper.rb