git_workflow 0.0.5

data/features/hooks/4205913_output_from_rake_tests_should_be_seen.feature

@@ -0,0 +1,19 @@
+# rake features FEATURE=features/hooks/4205913_output_from_rake_tests_should_be_seen.feature
+@hooks @needs_service
+Feature: Output from rake tests should be seen
+  Scenario: The output should be appearing
+    Given my Pivotal Tracker configuration is setup as normal
+    And I have "mine" callbacks enabled
+
+    Given the story 4205913 exists
+    And the name of story 4205913 is "Output from rake tests should be seen"
+
+    Given the local branch "4205913_output_from_rake_tests_should_be_seen" exists
+    And the local branch "4205913_output_from_rake_tests_should_be_seen" is active
+    And the rake task "spec" will fail
+    And the rake task "features" will fail
+
+    When I execute "git finish"
+
+    Then the stdout should contain "Running spec"
+    And the stderr should contain "Failing spec"

data/features/hooks/4424828_git_start_is_missing_pt_integration_for_my_hooks.feature

@@ -0,0 +1,15 @@
+# rake features FEATURE=4424828_git_start_is_missing_pt_integration_for_my_hooks
+@hooks @needs_service @my_workflow
+Feature: 'git start' should integrate with PT for my workflow
+  Scenario: Starting a new branch with my workflow
+    Given my Pivotal Tracker configuration is setup as normal
+    And I have "mine" callbacks enabled
+
+    Given the story 4424828 exists
+    And the name of story 4424828 is "'git start' is missing PT integration for my hooks"
+
+    When I successfully execute "git start 4424828"
+
+    Then the branch "4424828_git_start_is_missing_pt_integration_for_my_hooks" should be active
+    And the owner of story 4424828 should be "Matthew Denner"
+    And story 4424828 should be started

data/features/pivotal_tracker_api/4133291_chores_go_straight_to_accepted_not_to_finished.feature

@@ -0,0 +1,15 @@
+# rake features FEATURE=features/pivotal_tracker_api/4133291_chores_go_straight_to_accepted_not_to_finished.feature
+@pivotal_tracker_api @needs_service
+Feature: Finishing a chore means accepting it
+  Scenario: Finishing a chore
+    Given my Pivotal Tracker configuration is setup as normal
+
+    Given the story 4133291 exists
+    And story 4133291 is a chore
+    And the name of story 4133291 is "Chores go straight to 'accepted' not to 'finished'"
+
+    Given the local branch "4133291_chores_go_straight_to_accepted_not_to_finished" exists
+
+    When I successfully execute "git finish 4133291"
+
+    Then story 4133291 should be accepted

data/features/release/4132264_fix_the_libxml_warnings_from_nokogiri.feature

@@ -0,0 +1,20 @@
+# rake features FEATURE=features/release/4132264_fix_the_libxml_warnings_from_nokogiri.feature
+@release @needs_service
+Feature: Fix the LibXML warnings from Nokogiri
+  Background:
+    Given my Pivotal Tracker configuration is setup as normal
+
+    Given the story 4132264 exists
+    And the name of story 4132264 is "Fix the LibXML warnings from Nokogiri"
+
+  Scenario: Starting a branch
+    When I successfully execute "git start 4132264"
+
+    Then the output should not contain "I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2"
+
+  Scenario: Finishing a branch
+    Given the local branch "4132264_fix_the_libxml_warnings_from_nokogiri" exists
+
+    When I successfully execute "git finish 4132264"
+
+    Then the output should not contain "I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2"

data/features/step_definitions/aruba_extensions.rb

@@ -0,0 +1,4 @@
+# NOTE: only here because installed Aruba doesn't have this for some reason
+Given /^I cd to the root$/ do
+  @dirs = [ @dirs.first ]
+end

data/features/step_definitions/configuration_steps.rb

@@ -0,0 +1,38 @@
+Given /^my Pivotal Tracker configuration is setup as normal$/ do
+  Given %Q{my Pivotal Tracker username is "Matthew Denner"}
+  Given %Q{my Pivotal Tracker project ID is 93630}
+  Given %Q{my Pivotal Tracker token is 1234567890}
+  Given %Q{my local branch naming convention is "${number}_${name}"}
+  Given %Q{my remote branch naming convention is "${number}_${name}"}
+end
+
+Given /^my git username is "([^\"]+)"$/ do |username|
+  git_configure('user.name', username)
+end
+
+Given /^my Pivotal Tracker username is "([^\"]+)"$/ do |username|
+  git_configure('pt.username', username)
+end
+
+Given /^my Pivotal Tracker project ID is (\d+)$/ do |id|
+  git_configure('pt.projectid', id.to_i)
+  mock_service.project_id = id.to_i
+end
+
+Given /^my Pivotal Tracker token is ([a-zA-Z0-9]+)$/ do |token|
+  git_configure('pt.token', token)
+end
+
+Given /^my (local|remote) branch naming convention is "((?:(?:(?:\$\{[a-z][a-z_]+\})|[a-zA-Z0-9_]+)+))"$/ do |branch,convention|
+  git_configure("workflow.#{ branch }branchconvention", convention)
+end
+
+Given /^I have "([^\"]+)" callbacks enabled$/ do |callbacks|
+  git_configure("workflow.callbacks", callbacks)
+end
+
+def git_configure(key, value)
+  in_current_dir do
+    %x{git config '#{ key }' '#{ value }'}
+  end
+end

data/features/step_definitions/git_steps.rb

@@ -0,0 +1,102 @@
+def execute_silently(command)
+  %x{#{ command } > /dev/null 2>&1}
+end
+
+Given /^the local branch "([^\"]+)" exists$/ do |branch|
+  in_current_dir do
+    execute_silently(%Q{git checkout -b #{ branch } master})
+    execute_silently(%Q{git checkout master})
+  end
+end
+
+Given /^the local branch "([^\"]+)" is active$/ do |branch|
+  in_current_dir do
+    execute_silently(%Q{git checkout #{ branch }})
+  end
+end
+
+Then /^the branch "([^\"]*)" should be active$/ do |name|
+  in_current_dir do
+    %x{git branch}.split("\n").map(&:strip).should include("* #{ name }")
+  end
+end
+
+Then /^the branch "([^\"]*)" should be merged into master$/ do |name|
+  in_current_dir do
+    execute_silently(%Q{git checkout master})
+    %x{git branch --no-merge}.split("\n").map(&:strip).should_not include(name)
+  end
+end
+
+Then /^the branch "([^\"]+)" should not be merged into master$/ do |name|
+  in_current_dir do
+    execute_silently(%Q{git checkout master})
+    %x{git branch --no-merge}.split("\n").map(&:strip).should include(name)
+  end
+end
+
+When /^I( successfully)? execute "git (start|finish)([^\"]*)"$/ do |success,command,arguments|
+  root_path    = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  real_command = File.join(root_path, 'bin', "git-#{ command }")
+  lib_path     = File.join(root_path, 'lib')
+  When %Q{I#{ success } run "IGNORE_GIT_GLOBAL=true ruby -I#{ lib_path } -rrubygems #{ real_command } #{ arguments }"}
+end
+
+Given /^I commit "([^\"]+)"$/ do |filename|
+  in_current_dir do
+    execute_silently(%Q{git add '#{ filename }'})
+    execute_silently(%Q{git commit -m 'Committing "#{ filename }"' '#{ filename }'})
+  end
+end
+
+Then /^the parent of branch "([^\"]+)" should be "([^\"]+)"$/ do |child,parent|
+  in_current_dir do 
+    # This is probably the most hacky piece of shit I've written so far!
+    execute_silently("git checkout #{ child }")
+    output = %x{git show-branch --topo-order --current}
+    lines  = output.split("\n")
+
+    # Determine the branches that are matching and their offset in the output lines.
+    matchers = []
+    until lines.empty?
+      line = lines.shift
+      break if line =~ /^---.*$/
+
+      if line =~ /^(\s*)\*\s+\[#{ child }\]/
+        matchers[ $1.length ] = '\*'
+      elsif line =~ /^(\s*)!\s\[#{ parent }\]/
+        matchers[ $1.length ] = '\+'
+      end
+    end
+    raise StandardError, "Cannot find branches in list:\n#{ output }" unless [ '\*', '\+' ].all? { |m| matchers.include?(m) }
+    
+    # Find a line that matches the appropriate commit.  Basically when the two branches
+    # share a commit.  This doesn't work if the branches are intermerging.
+    regexp       = Regexp.new("^#{ matchers.map { |m| m || ' ' }.join }.+")
+
+    matched_line = nil
+    until lines.empty?
+      line = lines.shift
+      next unless line =~ regexp
+      matched_line = line
+      break
+    end
+    raise StandardError, "#{ child } appears not to be related to #{ parent }" if matched_line.nil?
+  end
+end
+
+Then /^the local and remote "([^\"]+)" branches should agree$/ do |branch|
+  Then %Q{the local branch "#{ branch }" and remote branch "#{ branch }" should agree}
+end
+
+Then /^the local branch "([^\"]+)" and remote branch "([^\"]+)" should agree$/ do |local,remote|
+  in_current_dir do
+    ref_to_sha = %x{git show-ref}.split("\n").inject({}) do |ref_to_sha, line|
+      match = line.match(%r{^([a-f0-9]+)\s+refs/(.+)$}) or raise StandardError, "Cannot parse ref line '#{ line }'"
+      ref_to_sha[ match[ 2 ] ] = match[ 1 ]
+      ref_to_sha
+    end
+
+    ref_to_sha[ "heads/#{ local }" ].should == ref_to_sha[ "remotes/origin/#{ remote }" ]
+  end
+end

data/features/step_definitions/misc_steps.rb

@@ -0,0 +1,3 @@
+Then /^fail now$/ do
+  raise StandardError, 'Failing as requested'
+end

data/features/step_definitions/pivotal_tracker_steps.rb

@@ -0,0 +1,43 @@
+Transform /^story (\d+)$/ do |id|
+  id.to_i
+end
+
+Given /^the story (\d+) exists$/ do |id|
+  create_story(id)
+end
+
+Given /^story (\d+) is a (feature|bug|chore)$/ do |id, type|
+  for_story(id) do |story|
+    story.story_type = type
+  end
+end
+
+Given /^the name of story (\d+) is "([^\"]+)"$/ do |id,name|
+  for_story(id) do |story|
+    story.name = name
+  end
+end
+
+Given /^the description of story (\d+) is "([^\"]+)"$/ do |id,description|
+  for_story(id) do |story|
+    story.description = description
+  end
+end
+
+Then /^story (\d+) should be (started|finished|delivered|rejected|accepted)$/ do |id,state|
+  for_story(id) do |story|
+    story.current_state.should == state
+  end
+end
+
+Then /^story (\d+) should have a comment of "([^\"]+)"$/ do |id,comment|
+  for_story(id) do |story|
+    story.comments.should include(comment)
+  end
+end
+
+Then /^the owner of story (\d+) should be "([^\"]+)"$/ do |id,owner|
+  for_story(id) do |story|
+    story.owned_by.should == owner
+  end
+end

data/features/step_definitions/project_code_steps.rb

@@ -0,0 +1,35 @@
+Given /^the rake task "([^\"]+)" will fail$/ do |task|
+  in_current_dir do
+    File.open('Rakefile', 'a+') do |file|
+      file << <<-END_OF_RAKE_TASK
+        task(:#{ task }) do
+          $stdout.puts "Running #{ task }"
+          $stderr.puts "Failing #{ task }"
+
+          raise 'Task "#{ task }" is setup to fail'
+        end
+      END_OF_RAKE_TASK
+    end
+    
+    # Add and commit the file
+    %x{git add Rakefile}
+    %x{git commit -m 'Upated #{ task } to fail' Rakefile}
+  end
+end
+
+Given /^the rake task "([^\"]+)" will succeed$/ do |task|
+  in_current_dir do
+    File.open('Rakefile', 'a+') do |file|
+      file << <<-END_OF_RAKE_TASK
+        task(:#{ task }) do
+          $stdout.puts "Running #{ task }"
+          $stderr.puts "Succeeding #{ task }"
+        end
+      END_OF_RAKE_TASK
+    end
+    
+    # Add and commit the file
+    %x{git add Rakefile}
+    %x{git commit -m 'Upated #{ task } to succeed' Rakefile}
+  end
+end

data/features/support/aruba.rb

@@ -0,0 +1 @@
+require 'aruba'

data/features/support/hooks/configuration.rb

@@ -0,0 +1,4 @@
+# Ensures that before every scenario the configuration is emptied
+Before do
+  @configuration = {}
+end

data/features/support/hooks/environment.rb

@@ -0,0 +1,49 @@
+# Ensures that the environment is setup appropriately for all scenarios
+Before do
+  # Modify the PATH so that the bin directory is available
+  @path_before = ENV['PATH']
+  ENV['PATH'] = "#{ File.expand_path(File.join(File.dirname(__FILE__), %w{.. .. .. bin})) }:#{ ENV['PATH'] }"
+
+  # We always need a local repository
+  Given %Q{a directory named "local_repository"}
+end
+
+Before('@needs_remote_repository') do
+  # Sets up the remote repository
+  Given %Q{a directory named "remote_repository"}
+  Given %Q{I cd to "remote_repository"}
+  Given %Q{I successfully run "git init --bare ."}
+
+  # Creates the local one by cloning the remote repository
+  Given %Q{I cd to the root}
+  Given %Q{I successfully run "git clone remote_repository local_repository"}
+
+  # This then sets up the master branch, both locally and remotely
+  Given %Q{I cd to "local_repository"}
+  Given %Q{an empty file named "basic-file"}
+  Given %Q{I successfully run "git add basic-file"}
+  Given %Q{I successfully run "git commit -a -m 'Initial project'"}
+  Given %Q{I successfully run "git push origin master"}
+end
+
+Before('~@needs_remote_repository') do
+  Given %Q{I cd to "local_repository"}
+  Given %Q{I successfully run "git init ."}
+  Given %Q{an empty file named "basic-file"}
+  Given %Q{I successfully run "git add basic-file"}
+  Given %Q{I successfully run "git commit -a -m 'Initial project'"}
+end
+
+Before do
+  Given %Q{I cd to the root}
+  Given %Q{I cd to "local_repository"}
+end
+
+# Tidy up the environmental setup
+After do
+  ENV['PATH'] = @path_before
+end
+
+def project_root
+  File.join(File.dirname(__FILE__), %w{.. .. ..})
+end

data/features/support/hooks/pivotal_tracker.rb

@@ -0,0 +1,170 @@
+require 'logger'
+require 'net/http'
+require 'sinatra'
+require 'ostruct'
+require 'builder'
+
+# Nokogiri doesn't like buggy LibXML2
+I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2 = true
+require 'nokogiri'
+
+# This is a fix-up for sinatra so that we can silence the output.  It allows us to
+# pass a Hash of options for webrick in the options passed to the #run! method.
+class Sinatra::Base
+  class << self
+    def run!(options={})
+      set options
+      handler      = detect_rack_handler
+      handler_name = handler.name.gsub(/.*::/, '')
+      handler.run(self, { :Host => bind, :Port => port }.merge(options.fetch(:webrick, {}))) do |server|
+        trap(:INT) do
+          ## Use thins' hard #stop! if available, otherwise just #stop
+          server.respond_to?(:stop!) ? server.stop! : server.stop
+        end
+        set :running, true
+      end
+    rescue Errno::EADDRINUSE => e
+      puts "== Someone is already performing on port #{port}!"
+    end
+  end
+end
+
+class PivotalTrackerService 
+  class MockService < Sinatra::Base
+    get '/services/v3/projects/:project_id/stories/:story_id' do |_, story_id|
+      handle_story(story_id) do |story|
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct!
+        xml.story {
+          xml.id(story.story_id, :type => 'integer')
+          [ :story_type, :current_state, :name, :owned_by, :description ].each do |element|
+            xml.tag!(element, story.send(element))
+          end
+        }
+        xml.to_s
+      end
+    end
+
+    put '/services/v3/projects/:project_id/stories/:story_id' do |_, story_id|
+      handle_story(story_id) do |story|
+        Nokogiri::XML(request.body.read).xpath('/story/*').each do |element|
+          story.send(:"#{ element.name }=", element.content)
+        end
+      end
+    end
+
+    post '/services/v3/projects/:project_id/stories/:story_id/notes' do |_, story_id|
+      handle_story(story_id) do |story|
+        comment = Nokogiri::XML(request.body.read).xpath('/note/text').first or raise StandardError, 'No comment body found!'
+        story.comments.push(comment.content)
+      end
+    end
+
+    def handle_story(id, &block)
+      self.class.handle_story(id, &block)
+    end
+
+    class << self
+      def stories
+        @stories ||= {}
+      end
+
+      def handle_story(id, &block)
+        story = stories[ id ] or raise StandardError, "Story #{ id } does not appear to exist"
+        yield(story)
+      end
+
+      def reset_stories!
+        @stories = {}
+      end
+
+      def create_story(id)
+        raise StandardError, "Story #{ id } already exists" unless stories[ id ].nil?
+        stories[ id ] = story = OpenStruct.new(
+          :story_id       => id, 
+          :story_type     => 'feature', 
+          :current_state  => 'not yet started', 
+          :owned_by       => '',
+          :name           => '',
+          :comments       => []
+        )
+      end
+
+      def for_story(id, &block)
+        story = stories[ id ] or raise StandardError, "Story #{ id } is undefined"
+        yield(story)
+      end
+    end
+  end
+
+  attr_writer :project_id
+
+  def initialize(host, port)
+    @host, @port = host, port.to_i
+  end
+
+  def run!
+    kill_previous_instance
+    start_sinatra
+    wait_for_sinatra_to_startup! 
+  end
+
+private
+
+  def kill_previous_instance
+    Thread.list.first.kill if Thread.list.size > 2
+  end
+
+  def start_sinatra
+    Thread.new do
+      # The effort you have to go through to silence Sinatra/WEBrick!
+      logger       = Logger.new(STDERR)
+      logger.level = Logger::FATAL
+
+      MockService.run!(:host => @host, :port => @port, :webrick => { :Logger => logger, :AccessLog => [] })
+    end
+  end
+
+  # We have to pause execution until Sinatra has come up.  This makes a number of attempts to
+  # retrieve the root document.  If it runs out of attempts it raises an exception
+  def wait_for_sinatra_to_startup!
+    (1..10).each do |_|
+      begin
+        Net::HTTP.get(URI.parse('http://localhost:7000/'))
+        return
+      rescue Errno::ECONNREFUSED => exception
+        sleep(1)
+      end
+    end
+
+    raise StandardError, "Our dummy webservice did not start up in time!"
+  end
+end
+
+mock_service = PivotalTrackerService.new('localhost', 7000)
+mock_service.run!
+self.class.instance_eval do
+  define_method(:mock_service) { mock_service }
+end
+eval <<-END_OF_WORLD_HOOKS
+  def create_story(id)
+    PivotalTrackerService::MockService.create_story(id)
+  end
+
+  def for_story(id, &block)
+    PivotalTrackerService::MockService.for_story(id, &block)
+  end
+END_OF_WORLD_HOOKS
+
+# This ensures that we have a behaviour similar to that of Pivotal Tracker.
+Before('@needs_service') do
+  @_http_proxy_before = ENV['http_proxy']
+  ENV['http_proxy']   = 'http://localhost:7000/'
+end
+
+After('@needs_service') do
+  ENV['http_proxy'] = @_http_proxy_before
+
+  PivotalTrackerService::MockService.reset_stories!
+end
+