git_reflow 0.2

data/features/step_definitions/git_steps.rb

@@ -0,0 +1,138 @@
+Given /^I have a git repository with a branch named "([^"]+)" checked out$/ do |branch_name|
+  steps %{
+    Given a directory named "master_repo"
+    And I cd to "master_repo"
+    And I write to "README" with:
+      | Initialized |
+    And I successfully run `git init`
+    And I successfully run `git add README`
+    And I successfully run `git commit -m "Initial commit"`
+  }
+
+  unless branch_name == "master"
+    steps %{
+      And I successfully run `git checkout -b #{branch_name}`
+    }
+  end
+
+  steps %{
+    And I cd to ".."
+  }
+end
+
+Given /^I have a remote git repository named "([^"]+)"$/ do |remote_name|
+  steps %{
+    Given a directory named "#{remote_name}_repo"
+    When I cd to "#{remote_name}_repo"
+    And I successfully run `git init`
+    And I write to "README" with:
+      | Initialized |
+    And I successfully run `git add .`
+    And I successfully run `git commit -am "Initial commit"`
+    And I cd to ".."
+    And I cd to "master_repo"
+    And I successfully run `git remote add #{remote_name} ../#{remote_name}_repo`
+    And I cd to ".."
+  }
+end
+
+Given /^the remote repository named "([^"]+)" has changes on the "([^"]+)" branch$/ do |remote_name, branch_name|
+  steps %{
+    Given a directory named "#{remote_name}_repo"
+    When I cd to "#{remote_name}_repo"
+    And I successfully run `git checkout #{branch_name}`
+    And I append to "README" with:
+      | changed |
+    And I successfully run `git add .`
+    And I successfully run `git commit -am "Changed readme"`
+    And I cd to ".."
+  }
+end
+
+Given /^the repository has been initialized$/ do
+  steps %{
+    Given I successfully run `git branch`
+    Then the output should contain "master"
+  }
+end
+
+Given /^I have a new branch named "([^"]+)" checked out$/ do |branch_name|
+  steps %{
+    When I cd to "master_repo"
+    And I successfully run `git checkout -b #{branch_name}`
+  }
+end
+
+Given /^I have a reviewed feature branch named "([^"]+)" checked out$/ do |branch_name|
+  pull = {
+    "title" => "Amazing new feature",
+    "body"  => "Please pull this in!",
+    "head"  => "reenhanced:#{branch_name}",
+    "base"  => "master",
+    "state" => "open"
+  }
+  stub_github_with(
+    :user => 'reenhanced',
+    :repo => 'repo',
+    :branch => branch_name,
+    :pull => pull
+  )
+
+  review_options = {
+    'base'  => pull['base'],
+    'title' => pull['title'],
+    'body'  => pull['body']
+  }
+
+  GitReflow.review review_options
+
+  # ensure we do not stay inside the remote repo
+  steps %{
+    Given I cd to ".."
+  }
+end
+
+When /^I deliver my "([^"]+)" branch$/ do |branch_name|
+  pull = {
+    "title" => "Amazing new feature",
+    "body"  => "Please pull this in!",
+    "head"  => "reenhanced:#{branch_name}",
+    "base"  => "master",
+    "state" => "open"
+  }
+  stub_github_with(
+    :user => 'reenhanced',
+    :repo => 'repo',
+    :branch => branch_name,
+    :pull => pull
+  )
+  GitReflow.deliver
+  GitReflow.stub(:current_branch).and_return("master")
+end
+
+Then /^a branch named "([^"]+)" should have been created from "([^"]+)"$/ do |new_branch, base_branch|
+  steps %{
+    Then the output should match /\\* \\[new branch\\]\\s* #{Regexp.escape(base_branch)}\\s* \\-\\> #{Regexp.escape(new_branch)}/
+  }
+end
+
+Then /^the base branch named "([^"]+)" should have fetched changes from the remote git repository "([^"]+)"$/ do |base_branch, remote_name|
+  steps %{
+    Then the output should match /\\* \\[new branch\\]\\s* #{Regexp.escape(base_branch)}\\s* \\-\\> #{remote_name}.#{Regexp.escape(base_branch)}/
+  }
+end
+
+Then /^the subcommand "([^"]+)" should run$/ do |subcommand|
+  has_subcommand?(subcommand).should be_true
+end
+
+Then /^the branch "([^"]+)" should be checked out$/ do |branch_name|
+  GitReflow.current_branch.should == branch_name
+end
+
+Then /^the branch "([^"]+)" should be up to date with the remote repository$/ do |branch_name|
+  steps %{
+    When I successfully run `git pull origin #{branch_name}`
+    Then the output should contain "Already up-to-date"
+  }
+end

data/features/support/env.rb

@@ -0,0 +1,27 @@
+require 'aruba/cucumber'
+require 'ruby-debug'
+require 'webmock/cucumber'
+require 'cucumber/rspec/doubles'
+
+Before('@gem') do
+  CukeGem.setup('./git_reflow.gemspec')
+end
+
+After('@gem') do
+  CukeGem.teardown
+end
+
+Before do
+  FileUtils.rm_rf Dir.glob("#{Dir.tmpdir}/aruba")
+end
+
+WebMock.disable_net_connect!
+
+def has_subcommand?(command)
+  # In order to see if a subcommand is run
+  # we have to look it up in Aruba's process list
+  # Aruba has a get_process helper, but it errors if none is found
+  # See: https://github.com/cucumber/aruba/blob/master/lib/aruba/api.rb#L239
+  found = processes.reverse.find{ |name, _| name == command }
+  found[-1] if found
+end

data/features/support/gem.rb

@@ -0,0 +1,85 @@
+# Thanks to:
+# Copyright 2011 Solano Labs All Rights Reserved
+# https://gist.github.com/1132465
+
+require 'aruba'
+require 'aruba/api'
+
+class CukeGem
+  @setup_done = false
+
+  class << self
+    include Aruba::Api
+
+    attr_reader :setup_done
+
+    def setup(gemspec, once=true)
+      gem_home = setup_env
+      if !@setup_done || !once then
+        @setup_done = true
+        mkgemdir(gem_home)
+        gem_install(gemspec)
+      end
+    end
+
+    def teardown
+      restore_env
+    end
+
+    def setup_env
+      tid = ENV['TDDIUM_TID'] || ''
+      gem_home = File.join(ENV['HOME'], 'tmp', 'aruba-gem')
+      gem_home = File.expand_path(gem_home)
+
+      set_env('GEM_HOME', gem_home)
+      set_env('GEM_PATH', gem_home)
+      set_env('BUNDLE_PATH', gem_home)
+      unset_bundler_env_vars
+
+      paths = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+      paths.unshift(File.join(gem_home, 'bin'))
+      set_env('PATH', paths.uniq.join(File::PATH_SEPARATOR))
+
+      return gem_home
+    end
+
+    def mkgemdir(gem_home)
+      FileUtils::rm_rf(gem_home)
+      FileUtils::mkdir_p(gem_home)
+
+      output = `gem install bundler`
+      if $?.exitstatus != 0 then
+        raise "unable to install bundler into #{gem_home}: #{output}"
+      end
+    end
+
+    def gem_install(gemspec)
+      gem_file = nil
+      begin
+        pwd = Dir.pwd
+        gemspec_dir = File.dirname(gemspec)
+        Dir.chdir(gemspec_dir)
+        output = `gem build #{File.basename(gemspec)}`
+        Dir.chdir(pwd)
+
+        if $?.exitstatus != 0 then
+          raise "unable to build gem: #{output}"
+        end
+
+        if output =~ /File:\s+([A-Za-z0-9_.-]+[.]gem)/ then
+          gem_file = $1
+          output = `gem install #{File.join(gemspec_dir, gem_file)}`
+          if $?.exitstatus != 0 then
+            raise "unable to install gem: #{output}"
+          end
+        else
+          raise "garbled gem build output: #{output}"
+        end
+      ensure
+        if gem_file then
+          FileUtils.rm_f(File.join(gemspec_dir, gem_file))
+        end
+      end
+    end
+  end
+end

data/features/support/github_helpers.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../../../spec/support/github_helpers', __FILE__)
+
+World(GithubHelpers)

data/features/user_delivers_flow.feature

@@ -0,0 +1,22 @@
+@gem
+Feature: User delivers a flow
+  As a User
+  I can deliver a flow
+  So I can merge in my topic branch
+
+  Background:
+    Given I have a git repository with a branch named "master" checked out
+    And I have a remote git repository named "origin"
+    And the remote repository named "origin" has changes on the "master" branch
+    And I cd to "master_repo"
+    When I run `git-reflow start new-branch`
+    And I append to "README" with:
+      | changed |
+    And I successfully run `git add .`
+    And I successfully run `git commit -am "Changed readme"`
+    Given I have a reviewed feature branch named "new-feature" checked out
+
+  Scenario: User runs git-reflow deliver without any parameters
+    When I deliver my "new-feature" branch
+    Then the branch "master" should be checked out
+    And the branch "master" should be up to date with the remote repository

data/features/user_installs_gem.feature

@@ -0,0 +1,18 @@
+Feature: User installs gem
+  As a user
+  When I install a gem
+  It should initialize the gem configuration
+
+  Scenario: User installs gem
+    When I build and install the gem
+    Then the output should contain "You need to setup your GitHub OAuth token\nPlease run 'git-reflow setup'"
+    When I successfully run `git-reflow`
+    Then the output should contain "usage: git-reflow [global options] command [command options]"
+
+  Scenario: User sets up GitHub
+    When I run `git-reflow setup` interactively
+    And I type "user"
+    And I type "password"
+    Then the output should contain "Please enter your GitHub username: "
+    And the output should contain "Please enter your GitHub password (we do NOT store this): "
+    And the output should contain "Your GitHub account was successfully setup!"

data/features/user_starts_flow.feature

@@ -0,0 +1,19 @@
+@gem
+Feature: User starts a new flow
+  As a User
+  When I start a new flow
+  I should be on a new working feature branch
+
+  Scenario: User runs git-reflow start without any parameters
+    When I run `git-reflow start`
+    Then the output should contain "usage: git-reflow start [new-branch-name]"
+
+  Scenario: User runs git-reflow start with new branch name
+    Given I have a git repository with a branch named "master" checked out
+    And I have a remote git repository named "origin"
+    And the remote repository named "origin" has changes on the "master" branch
+    And I cd to "master_repo"
+    When I run `git-reflow start new-branch`
+    Then a branch named "new-branch" should have been created from "master"
+    And the base branch named "master" should have fetched changes from the remote git repository "origin"
+    And the output should contain "Switched to a new branch 'new-branch'"

data/git_reflow.gemspec

@@ -0,0 +1,32 @@
+# Ensure we require the local version and not one we might have installed already
+require File.join([File.dirname(__FILE__),'lib','git_reflow/version.rb'])
+spec = Gem::Specification.new do |s|
+  s.name             = 'git_reflow'
+  s.version          = GitReflow::VERSION
+  s.authors          = ["Valentino Stoll", "Robert Stern", "Nicholas Hance"]
+  s.email            = ["dev@reenhanced.com"]
+  s.homepage         = "http://github.com/reenhanced/gitreflow"
+  s.summary          = "A better git process"
+  s.description      = "Git Reflow manages your git workflow."
+  s.platform         = Gem::Platform::RUBY
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ['README.rdoc']
+  s.bindir           = 'bin'
+  s.require_paths    << 'lib'
+  s.rdoc_options     << '--title' << 'git_reflow' << '--main' << 'README.rdoc' << '-ri'
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('aruba', '~> 0.4.6')
+  s.add_development_dependency('jeweler')
+  s.add_development_dependency('webmock')
+  s.add_dependency('gli', '2.0.0')
+  s.add_dependency('json_pure', '1.7.5')
+  s.add_dependency('highline')
+  s.add_dependency('httpclient')
+  s.add_dependency('github_api', '0.6.5')
+  s.post_install_message = "You need to setup your GitHub OAuth token\nPlease run 'git-reflow setup'"
+end

data/lib/git_reflow/version.rb

@@ -0,0 +1,3 @@
+module GitReflow
+  VERSION = "0.2"
+end

data/lib/git_reflow.rb

@@ -0,0 +1,233 @@
+require 'rubygems'
+require 'rake'
+require 'json/pure'
+require 'open-uri'
+require "highline/import"
+require 'httpclient'
+require 'github_api'
+
+module GitReflow
+  extend self
+
+  LGTM = /lgtm|looks good to me|:\+1:|:thumbsup:/i
+
+  def setup
+    gh_user = ask "Please enter your GitHub username: "
+    gh_password = ask "Please enter your GitHub password (we do NOT store this): "
+    puts "\nYour GitHub account was successfully setup!"
+    github = Github.new :basic_auth => "#{gh_user}:#{gh_password}"
+    authorization = github.oauth.create 'scopes' => ['repo']
+    oauth_token = authorization[:token]
+    set_oauth_token(oauth_token)
+  end
+
+  def review(options = {})
+    options['base'] ||= 'master'
+    fetch_destination options['base']
+
+    begin
+      puts push_current_branch
+      pull_request = github.pull_requests.create(remote_user, remote_repo_name,
+                                          'title' => options['title'],
+                                          'body' => options['body'],
+                                          'head' => "#{remote_user}:#{current_branch}",
+                                          'base' => options['base'])
+
+      puts "Successfully created pull request ##{pull_request.number}: #{pull_request.title}\nPull Request URL: #{pull_request.html_url}\n"
+      ask_to_open_in_browser(pull_request.html_url)
+    rescue Github::Error::UnprocessableEntity => e
+      error_message = e.to_s
+      if error_message =~ /request already exists/i
+        existing_pull_request = find_pull_request( :from => current_branch, :to => options['base'] )
+        puts "Existing pull request at: #{existing_pull_request[:html_url]}"
+        ask_to_open_in_browser(existing_pull_request.html_url)
+      else
+        puts error_message
+      end
+    end
+  end
+
+  def deliver(options = {})
+    feature_branch    = current_branch
+    options['base'] ||= 'master'
+    fetch_destination options['base']
+
+    begin
+      existing_pull_request = find_pull_request( :from => current_branch, :to => options['base'] )
+
+      if existing_pull_request.nil?
+        puts "Error: No pull request exists for #{remote_user}:#{current_branch}\nPlease submit your branch for review first with \`git reflow review\`"
+      else
+
+        open_comment_authors = find_authors_of_open_pull_request_comments(existing_pull_request)
+
+        # if there any comment_authors left, then they haven't given a lgtm after the last commit
+        if open_comment_authors.empty?
+          lgtm_authors   = comment_authors_for_pull_request(existing_pull_request, :with => LGTM)
+          commit_message = get_first_commit_message
+          puts "Merging pull request ##{existing_pull_request[:number]}: '#{existing_pull_request[:title]}', from '#{existing_pull_request[:head][:label]}' into '#{existing_pull_request[:base][:label]}'"
+
+          update_destination(options['base'])
+          merge_feature_branch(:feature_branch => feature_branch,
+                               :destination_branch => options['base'],
+                               :pull_request_number => existing_pull_request[:number],
+                               :message => "\nCloses ##{existing_pull_request[:number]}\n\nLGTM given by: @#{lgtm_authors.join(', @')}\n")
+          append_to_squashed_commit_message(commit_message)
+          committed = system('git commit')
+
+          if committed
+            puts "Merge complete!"
+            deploy_and_cleanup = ask "Would you like to push this branch to your remote repo and cleanup your feature branch? "
+            if deploy_and_cleanup =~ /^y/i
+              puts `git push origin #{options['base']}`
+              puts `git push origin :#{feature_branch}`
+              puts `git br -D #{feature_branch}`
+              puts "Nice job buddy."
+            end
+          else
+            puts "There were problems commiting your feature... please check the errors above and try again."
+          end
+        else
+          puts "[deliver halted] You still need a LGTM from: #{open_comment_authors.join(', ')}"
+        end
+      end
+
+    rescue Github::Error::UnprocessableEntity => e
+      errors = JSON.parse(e.response_message[:body])
+      error_messages = errors["errors"].collect {|error| "GitHub Error: #{error["message"].gsub(/^base\s/, '')}" unless error["message"].nil?}.compact.join("\n")
+      puts error_messages
+    end
+  end
+
+  def github
+    @github ||= Github.new :oauth_token => get_oauth_token
+  end
+
+  def get_oauth_token
+    `git config --get github.oauth-token`.strip
+  end
+
+  def current_branch
+    `git branch --no-color | grep '^\* ' | grep -v 'no branch' | sed 's/^* //g'`.strip
+  end
+
+  def github_user
+    `git config --get github.user`.strip
+  end
+
+  def remote_user
+    gh_remote_user = `git config --get remote.origin.url`.strip
+    gh_remote_user.slice!(/github\.com[\/:](\w|-|\.)+/i)[11..-1]
+  end
+
+  def remote_repo_name
+    gh_repo = `git config --get remote.origin.url`.strip
+    gh_repo.slice(/\/(\w|-|\.)+$/i)[1..-5]
+  end
+
+  def get_first_commit_message
+    `git log --pretty=format:"%s" --no-merges -n 1`.strip
+  end
+
+  private
+
+  def set_oauth_token(oauth_token)
+    `git config --global --replace-all github.oauth-token #{oauth_token}`
+  end
+
+  def push_current_branch
+    `git push origin #{current_branch}`
+  end
+
+  def fetch_destination(destination_branch)
+    `git fetch origin #{destination_branch}`
+  end
+
+  def update_destination(destination_branch)
+    origin_branch = current_branch
+    `git checkout #{destination_branch}`
+    puts `git pull origin #{destination_branch}`
+    `git checkout #{origin_branch}`
+  end
+
+  def merge_feature_branch(options = {})
+    options[:destination_branch] ||= 'master'
+    message                        = options[:message] || "\nCloses ##{options[:pull_request_number]}\n"
+
+    `git checkout #{options[:destination_branch]}`
+    puts `git merge --squash #{options[:feature_branch]}`
+    # append pull request number to commit message
+    append_to_squashed_commit_message(message)
+  end
+
+  def append_to_squashed_commit_message(message = '')
+    `echo "#{message}" | cat - .git/SQUASH_MSG > ./tmp_squash_msg`
+    `mv ./tmp_squash_msg .git/SQUASH_MSG`
+  end
+
+  def find_pull_request(options)
+    existing_pull_request = nil
+    github.pull_requests.all(remote_user, remote_repo_name, :state => 'open') do |pull_request|
+      if pull_request[:base][:label] == "#{remote_user}:#{options[:to]}" and
+         pull_request[:head][:label] == "#{remote_user}:#{options[:from]}"
+         existing_pull_request = pull_request
+         break
+      end
+    end
+    existing_pull_request
+  end
+
+  def find_authors_of_open_pull_request_comments(pull_request)
+    # first we'll gather all the authors that have commented on the pull request
+    comments        = github.issues.comments.all remote_user, remote_repo_name, pull_request[:number]
+    review_comments = github.pull_requests.comments.all remote_user, remote_repo_name, pull_request[:number]
+    all_comments    = comments + review_comments
+    comment_authors = comment_authors_for_pull_request(pull_request)
+
+    # now we need to check that all the commented authors have given a lgtm after the last commit
+    all_comments.each do |comment|
+      next unless comment_authors.include?(comment.user.login)
+      pull_last_committed_at = Time.parse pull_request.head.repo.updated_at
+      comment_created_at     = Time.parse(comment.created_at)
+      if comment_created_at > pull_last_committed_at
+        if comment.body =~ LGTM
+          comment_authors -= [comment.user.login]
+        else
+          comment_authors << comment.user.login unless comment_authors.include?(comment.user.login)
+        end
+      end
+    end
+
+    comment_authors || []
+  end
+
+  def comment_authors_for_pull_request(pull_request, options = {})
+    comments        = github.issues.comments.all remote_user, remote_repo_name, pull_request[:number]
+    review_comments = github.pull_requests.comments.all remote_user, remote_repo_name, pull_request[:number]
+    all_comments    = comments + review_comments
+    comment_authors = []
+
+    all_comments.each do |comment|
+      comment_authors << comment.user.login if !comment_authors.include?(comment.user.login) and (options[:with].nil? or comment.body =~ options[:with])
+    end
+
+    # remove the current user from the list to check
+    comment_authors -= [github_user]
+  end
+
+  # WARNING: this currently only supports OS X and UBUNTU
+  def ask_to_open_in_browser(url)
+    if RUBY_PLATFORM =~ /darwin|linux/i
+      open_in_browser = ask "Would you like to open it in your browser? "
+      if open_in_browser =~ /^y/i
+        if RUBY_PLATFORM =~ /darwin/i
+          # OS X
+          `open #{url}`
+        else
+          # Ubuntu
+          `xdg-open #{url}`
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/git/git_config

@@ -0,0 +1,7 @@
+[user]
+	name = Reenhanced
+	email = dev@reenhanced.com
+[github]
+	user = reenhanced
+	token = 123456
+	oauth-token = 123456