github-pivotal-flow 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b01fca13c1d638c7aaaa3ad82ca7015446622e46
-  data.tar.gz: 314ca596836512bbef1f685e41f995f2afdce0b6
+  metadata.gz: 423519e9574e2048faaaec36c2583c3ec79273eb
+  data.tar.gz: 03fb90bd37c4fb777432e1e9c6c9732ac90b25cf
 SHA512:
-  metadata.gz: 4a077289ddeb860882b9dea4779ac2be616783fabef1a1f6589c4c418c19200fced196d8495cdb3ca26848767b9ba8aab5f19ae557bcdfa112d567852d2e6def
-  data.tar.gz: e37b3831fcb8b0f6af1310fe80b4f86d3ecf9cca6aeb5a3a25e386e8cc7b63a65a7a6160ad6485d9be468ceba851fc96d79480189855edb0c95ae5811e864778
+  metadata.gz: 2aa8e365a3df85d33431476ca8c8b93bf022edce02ec2f2655f9e32e547469fc6ac36aa9978928b257c09f925505c7d0ce69f77cc24f033b28f0237f9826fa44
+  data.tar.gz: e6a57b30856b8cfffad4b65b6f34e51109a6240b666e1c4cd1026b2275e2e7b0f40a0dfc3f7102432ece7a5ca4354b86f6fc0c1ae3a6a905b1b9e75dded30bf3

data/lib/github_pivotal_flow.rb

@@ -20,6 +20,22 @@ require 'pivotal-tracker'
 
 require File.join('core_ext', 'object', 'blank')
 
+module GithubPivotalFlow
+  KEY_USER_NAME = 'user.name'.freeze
+  KEY_API_TOKEN = 'pivotal.api-token'.freeze
+  KEY_PROJECT_ID = 'pivotal.project-id'.freeze
+  KEY_STORY_ID = 'pivotal-story-id'.freeze
+  KEY_FEATURE_PREFIX = 'gitflow.prefix.feature'.freeze
+  KEY_HOTFIX_PREFIX = 'gitflow.prefix.hotfix'.freeze
+  KEY_RELEASE_PREFIX = 'gitflow.prefix.release'.freeze
+  KEY_DEVELOPMENT_BRANCH = 'gitflow.branch.develop'.freeze
+  KEY_MASTER_BRANCH = 'gitflow.branch.master'.freeze
+  KEY_GITHUB_USERNAME = 'github.username'.freeze
+  KEY_GITHUB_API_TOKEN = 'github.api-token'.freeze
+end
+
+require File.join('github_pivotal_flow', 'version')
+
 require File.join('github_pivotal_flow', 'shell')
 require File.join('github_pivotal_flow', 'git')
 require File.join('github_pivotal_flow', 'project')

data/lib/github_pivotal_flow/command.rb

@@ -15,21 +15,10 @@ module GithubPivotalFlow
       @options = {}
       args = parse_argv(*args)
       @options[:args] = args
-
-      @repository_root = Git.repository_root
       @configuration = Configuration.new(@options)
-
-      PivotalTracker::Client.token = @configuration.api_token
-      PivotalTracker::Client.use_ssl = true
-
-      @project = PivotalTracker::Project.find @configuration.project_id
-
-      # Make sure that all the git flow config options are set up
-      @configuration.development_branch
-      @configuration.master_branch
-      @configuration.feature_prefix
-      @configuration.hotfix_prefix
-      @configuration.release_prefix
+      # Validate the configuration to make sure everything is set up correctly
+      @configuration.validate
+      @project = @configuration.project
     end
 
     # The main entry point to the command's execution

data/lib/github_pivotal_flow/configuration.rb

@@ -9,6 +9,31 @@ module GithubPivotalFlow
       @github_password_cache = {}
     end
 
+    def validate
+      repository_root
+      user_name
+      ensure_github_api_token
+      ensure_pivotal_api_token
+      ensure_gitflow_config
+      project.config = self
+      return true
+    end
+
+    def repository_root
+      @repository_root ||= Git.repository_root
+    end
+
+    def user_name
+      user_name = Git.get_config(KEY_USER_NAME, :inherited).strip
+      if user_name.blank?
+        user_name = ask('Github user name (Should be the same as in your Pivotal profile): ').strip
+        Git.set_config(KEY_USER_NAME, user_name, :local) unless user_name.blank?
+        puts
+      end
+
+      user_name
+    end
+
     # Returns the user's Pivotal Tracker API token.  If this token has not been
     # configured, prompts the user for the value.  The value is checked for in
     # the _inherited_ Git configuration, but is stored in the _global_ Git
@@ -18,15 +43,33 @@ module GithubPivotalFlow
     def api_token
       api_token = @options[:api_token] || Git.get_config(KEY_API_TOKEN, :inherited)
 
-      if api_token.empty?
+      if api_token.blank?
         api_token = ask('Pivotal API Token (found at https://www.pivotaltracker.com/profile): ').strip
-        Git.set_config KEY_API_TOKEN, api_token, :global
+        Git.set_config(KEY_API_TOKEN, api_token, :local) unless api_token.blank?
         puts
       end
 
       api_token
     end
 
+    def ensure_pivotal_api_token
+      PivotalTracker::Client.use_ssl = true
+      while (PivotalTracker::Client.token = self.api_token).blank? || PivotalTracker::Project.all.empty?
+        puts "No projects found."
+        clear_pivotal_api_token!
+      end
+      return true
+    rescue RestClient::Unauthorized => e
+      puts "Invalid Pivotal token"
+      clear_pivotal_api_token!
+      retry
+    end
+
+    def clear_pivotal_api_token!
+      PivotalTracker::Client.token = nil
+      Git.delete_config(KEY_API_TOKEN, :local)
+    end
+
     # Returns the Pivotal Tracker project id for this repository.  If this id
     # has not been configuration, prompts the user for the value.  The value is
     # checked for in the _inherited_ Git configuration, but is stored in the
@@ -45,18 +88,22 @@ module GithubPivotalFlow
           end
         end
 
-        Git.set_config KEY_PROJECT_ID, project_id, :local
+        Git.set_config(KEY_PROJECT_ID, project_id, :local)
         puts
       end
 
       project_id
     end
 
-    # Returns the story associated with the current development branch
+    def project
+      @project ||= Project.new(config: self)
+    end
+
+    # Returns the story associated with the branch
     #
-    # @param [PivotalTracker::Project] project the project the story belongs to
-    # @return [PivotalTracker::Story] the story associated with the current development branch
-    def story(project)
+    # @return [Story] the story associated with the current development branch
+    def story
+      return @story if @story
       story_id = Git.get_config(KEY_STORY_ID, :branch)
       if story_id.blank? && (matchdata = /^[a-z0-9_\-]+\/(\d+)(-[a-z0-9_\-]+)?$/i.match(Git.current_branch))
         story_id = matchdata[1]
@@ -67,7 +114,7 @@ module GithubPivotalFlow
         Git.set_config(KEY_STORY_ID, story_id, :branch) unless story_id.blank?
       end
       return nil if story_id.blank?
-      Story.new(project.stories.find(story_id.to_i), :branch_name => Git.current_branch)
+      return (@story = Story.new(project, project.stories.find(story_id.to_i), branch_name: Git.current_branch))
     end
 
     # Stores the story associated with the current development branch
@@ -86,7 +133,6 @@ module GithubPivotalFlow
         feature_prefix = 'feature/' if feature_prefix.blank?
         feature_prefix = "#{feature_prefix}/" unless feature_prefix[-1,1] == '/'
         Git.set_config KEY_FEATURE_PREFIX, feature_prefix, :local
-        puts
       end
 
       feature_prefix
@@ -100,7 +146,6 @@ module GithubPivotalFlow
         hotfix_prefix = 'hotfix/' if hotfix_prefix.blank?
         hotfix_prefix = "#{hotfix_prefix}/" unless hotfix_prefix[-1,1] == '/'
         Git.set_config KEY_HOTFIX_PREFIX, hotfix_prefix, :local
-        puts
       end
 
       hotfix_prefix
@@ -113,8 +158,7 @@ module GithubPivotalFlow
         release_prefix = ask('Please enter your git-flow release branch prefix: [release/]').strip
         release_prefix = 'release' if release_prefix.blank?
         release_prefix = "#{release_prefix}/" unless release_prefix[-1,1] == '/'
-        Git.set_config KEY_RELEASE_PREFIX, release_prefix, :local
-        puts
+        Git.set_config(KEY_RELEASE_PREFIX, release_prefix, :local)
       end
 
       release_prefix
@@ -125,9 +169,8 @@ module GithubPivotalFlow
 
       if development_branch.empty?
         development_branch = ask('Please enter your git-flow development branch name: [development]').strip
-        development_branch = 'development' if development_branch.nil? || development_branch.empty?
+        development_branch = 'development' if development_branch.blank?
         Git.set_config KEY_DEVELOPMENT_BRANCH, development_branch, :local
-        puts
       end
       Git.ensure_branch_exists(development_branch)
 
@@ -139,20 +182,27 @@ module GithubPivotalFlow
 
       if master_branch.blank?
         master_branch = ask('Please enter your git-flow production branch name: [master]').strip
-        master_branch = 'master' if master_branch.nil? || master_branch.empty?
+        master_branch = 'master' if master_branch.blank?
         Git.set_config KEY_MASTER_BRANCH, master_branch, :local
-        puts
       end
       Git.ensure_branch_exists(master_branch)
 
       master_branch
     end
 
-    def github_project
-      @github_project ||= Project.from_url(Git.get_config("remote.#{Git.get_remote}.url"))
+    def ensure_gitflow_config
+      development_branch && master_branch && feature_prefix && hotfix_prefix && release_prefix
+    end
+
+    def github_client
+      @ghclient ||= GitHubAPI.new(self, :app_url => 'http://github.com/roomorama/github-pivotal-flow')
     end
 
-    def github_username(host)
+    def github_host
+      project.host
+    end
+
+    def github_username(host = github_host)
       return ENV['GITHUB_USER'] unless ENV['GITHUB_USER'].to_s.blank?
       github_username = Git.get_config KEY_GITHUB_USERNAME, :inherited
       if github_username.blank?
@@ -162,27 +212,54 @@ module GithubPivotalFlow
       github_username
     end
 
-    def github_username=(github_username)
-      Git.set_config KEY_GITHUB_USERNAME, github_username, :local unless github_username.blank?
+    def github_username=(username)
+      Git.set_config KEY_GITHUB_USERNAME, username, :local unless username.blank?
     end
 
-    def github_password(host, user)
-      return ENV['GITHUB_PASSWORD'] unless ENV['GITHUB_PASSWORD'].to_s.empty?
-      @github_password_cache["#{user}"] ||= ask_password(user)
+    def github_password(host = github_host, user = nil)
+      return ENV['GITHUB_PASSWORD'] unless ENV['GITHUB_PASSWORD'].to_s.blank?
+      user ||= github_username(host)
+      @github_password_cache["#{user}"] ||= ask_github_password(user)
     end
 
-    def github_api_token(host, user)
+    def clear_github_auth_data!
+      @github_password_cache = {}
+      Git.delete_config(KEY_GITHUB_USERNAME, :local)
+    end
+
+    def ensure_github_api_token
+      begin
+        repo_found = github_client.repo_exists?(project)
+      end while github_api_token.blank?
+      raise("Could not find github project") unless repo_found
+    rescue Net::HTTPServerException => e
+      case e.response.code
+      when '401'
+        say "Invalid username/password combination. Please try again:"
+      else
+        say "Unknown error (#{e.response.code}). Please try again: "
+      end
+      clear_github_auth_data!
+      retry
+    end
+
+    def github_api_token(host = nil, user = nil)
+      host ||= github_host
+      user ||= github_username
       github_token = Git.get_config KEY_GITHUB_API_TOKEN, :inherited
       if github_token.blank?
-        github_token = yield
-        Git.set_config KEY_GITHUB_API_TOKEN, github_token, :local
+        if block_given?
+          github_token = yield
+        end
+        Git.set_config(KEY_GITHUB_API_TOKEN, github_token, :global) unless github_token.blank?
       end
       github_token
     end
 
     # special prompt that has hidden input
-    def ask_password(user)
-      print "Github password for #{user} (never stored): "
+    def ask_github_password(username = nil)
+      username ||= github_username
+      print "Github password for #{username} (never stored): "
       if $stdin.tty?
         password = askpass
         puts ''
@@ -247,18 +324,5 @@ module GithubPivotalFlow
         URI.parse proxy
       end
     end
-
-    private
-
-    KEY_API_TOKEN = 'pivotal.api-token'.freeze
-    KEY_PROJECT_ID = 'pivotal.project-id'.freeze
-    KEY_STORY_ID = 'pivotal-story-id'.freeze
-    KEY_FEATURE_PREFIX = 'gitflow.prefix.feature'.freeze
-    KEY_HOTFIX_PREFIX = 'gitflow.prefix.hotfix'.freeze
-    KEY_RELEASE_PREFIX = 'gitflow.prefix.release'.freeze
-    KEY_DEVELOPMENT_BRANCH = 'gitflow.branch.develop'.freeze
-    KEY_MASTER_BRANCH = 'gitflow.branch.master'.freeze
-    KEY_GITHUB_USERNAME = 'github.username'.freeze
-    KEY_GITHUB_API_TOKEN = 'github.api-token'.freeze
   end
 end

data/lib/github_pivotal_flow/finish.rb

@@ -4,7 +4,7 @@ module GithubPivotalFlow
 
     # Finishes a Pivotal Tracker story
     def run!
-      story = @configuration.story(@project)
+      story = @configuration.story
       story.can_merge?
       commit_message = options[:commit_message]
       if story.release?

data/lib/github_pivotal_flow/git.rb

@@ -45,6 +45,7 @@ module GithubPivotalFlow
     def self.merge(branch_name, options = {})
       command = "git merge --quiet"
       command << " --no-ff" if options[:no_ff]
+      command << " --ff" if options[:ff] && !options[:no_ff]
       command << " -m \"#{options[:commit_message]}\"" unless options[:commit_message].blank?
       exec "#{command} #{branch_name}"
       puts 'OK'
@@ -118,6 +119,19 @@ module GithubPivotalFlow
       else
         raise "Unable to set Git configuration for scope '#{scope}'"
       end
+      return value
+    end
+
+    def self.delete_config(key, scope = :local)
+      if :branch == scope
+        exec "git config --local --unset branch.#{self.current_branch}.#{key}"
+      elsif :global == scope
+        exec "git config --global --unset #{key}"
+      elsif :local == scope
+        exec "git config --local --unset #{key}"
+      else
+        raise "Unable to delete Git configuration for scope '#{scope}'"
+      end
     end
 
     def self.repository_root
@@ -149,6 +163,14 @@ module GithubPivotalFlow
       end
     end
 
+    def self.clean_working_tree?
+      exec("git diff --no-ext-diff --ignore-submodules --quiet --exit-code", false)
+      fail("fatal: Working tree contains unstaged changes. Aborting.") if $?.exitstatus != 0
+      exec("git diff-index --cached --quiet --ignore-submodules HEAD --", false)
+      fail("fatal: Index contains uncommited changes. Aborting.") if $?.exitstatus != 0
+      return true
+    end
+
     private
     def self.escape_commit_message(message)
       message.gsub('"', '\"').sub(/!\z/, '! ')

data/lib/github_pivotal_flow/github_api.rb

@@ -34,6 +34,15 @@ module GithubPivotalFlow
       end
     end
 
+    def repo_info project
+      get "https://%s/repos/%s/%s" %
+              [api_host(project.host), project.owner, project.name]
+    end
+
+    def repo_exists? project
+      repo_info(project).success?
+    end
+
     # Returns parsed data from the new pull request.
     def create_pullrequest options
       project = options.fetch(:project)
@@ -124,7 +133,7 @@ module GithubPivotalFlow
           create_connection host_url
         end
 
-        req['User-Agent'] = "Hub 1.11.1"
+        req['User-Agent'] = "Github-pivotal-flow #{GithubPivotalFlow::VERSION}"
         apply_authentication(req, url)
         yield req if block_given?
         finalize_request(req, url)
@@ -204,7 +213,6 @@ module GithubPivotalFlow
 
       def obtain_oauth_token host, user, two_factor_code = nil
         auth_url = URI.parse("https://%s@%s/authorizations" % [CGI.escape(user), host])
-
         # dummy request to trigger a 2FA SMS since a HTTP GET won't do it
         post(auth_url) if !two_factor_code
 

data/lib/github_pivotal_flow/project.rb

@@ -1,21 +1,29 @@
 module GithubPivotalFlow
-  class Project < Struct.new(:owner, :name, :host)
-    def self.from_url(url)
+  class Project
+    attr_accessor :owner, :name, :host, :config
+
+    def self.find(id)
+      id = id.to_i if id.is_a?(String)
+      return PivotalTracker::Project.find(id)
+    end
+
+    def initialize(args = {})
+      args.each do |k,v|
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+      url = Git.get_config("remote.#{Git.get_remote}.url")
       if (matchdata = /^git@([a-z0-9\._-]+):([a-z0-9_-]+)\/([a-z0-9_-]+)(\.git)?$/.match(url.strip))
-        host = matchdata[1]
-        owner = matchdata[2]
-        name = matchdata[3]
+        self.host ||= matchdata[1]
+        self.owner ||= matchdata[2]
+        self.name ||= matchdata[3]
       else
         url = URI(url) if !url.is_a?(URI)
-        _, owner, name = url.path.split('/', 4)
-        host = url.host
+        path_components = url.path.split('/', 4)
+        self.owner ||= path_components[1]
+        self.name ||= path_components[2]
+        self.host ||= url.host
       end
-      self.new(owner, name.sub(/\.git$/, ''), host)
-    end
-
-    def initialize(*args)
-      super
-      self.name = self.name.tr(' ', '-')
+      self.name = self.name.tr(' ', '-').sub(/\.git$/, '')
       self.host ||= 'github.com'
       self.host = host.sub(/^ssh\./i, '') if 'ssh.github.com' == host.downcase
     end
@@ -27,5 +35,13 @@ module GithubPivotalFlow
     def ==(other)
       name_with_owner == other.name_with_owner
     end
+
+    def pivotal_project
+      @pivotal_project ||= self.class.find(self.config.project_id)
+    end
+
+    def method_missing(m, *args, &block)
+      return pivotal_project.send(m, *args, &block)
+    end
   end
 end

data/lib/github_pivotal_flow/start.rb

@@ -11,8 +11,10 @@ module GithubPivotalFlow
       @configuration.story = story # Tag the branch with story attributes
       Git.add_hook 'prepare-commit-msg', File.join(File.dirname(__FILE__), 'prepare-commit-msg.sh')
       unless story.release?
-        @ghclient = GitHubAPI.new(@configuration, :app_url => 'http://github.com/roomorama/github-pivotal-flow')
-        create_pull_request_for_story!(story)
+        print "Creating pull-request on Github... "
+        pull_request_params = story.params_for_pull_request.merge(project: @configuration.project)
+        @configuration.github_client.create_pullrequest(pull_request_params)
+        puts 'OK'
       end
       story.mark_started!
       return 0
@@ -20,12 +22,6 @@ module GithubPivotalFlow
 
     private
 
-    def create_pull_request_for_story!(story)
-      print "Creating pull-request on Github... "
-      @ghclient.create_pullrequest({:project => @configuration.github_project}.merge(story.params_for_pull_request))
-      puts 'OK'
-    end
-
     def parse_argv(*args)
       OptionParser.new do |opts|
         opts.banner = "Usage: git start <feature|chore|bug|story_id>"

data/lib/github_pivotal_flow/story.rb

@@ -1,7 +1,7 @@
 # Utilities for dealing with +PivotalTracker::Story+s
 module GithubPivotalFlow
   class Story
-    attr_accessor :story, :branch_name, :root_branch_name
+    attr_accessor :pivotal_story, :project, :branch_name, :root_branch_name
 
     # Print a human readable version of a story.  This pretty prints the title,
     # description, and notes for the story.
@@ -28,7 +28,7 @@ module GithubPivotalFlow
 
     # Selects a Pivotal Tracker story by doing the following steps:
     #
-    # @param [PivotalTracker::Project] project the project to select stories from
+    # @param [Project] project the project to select stories from
     # @param [String, nil] filter a filter for selecting the story to start.  This
     #   filter can be either:
     #   * a story id: selects the story represented by the id
@@ -42,20 +42,22 @@ module GithubPivotalFlow
       else
         story = find_story project, filter, limit
       end
-      self.new(story)
+      self.new(project, story)
     end
 
-    # @param [PivotalTracker::Story] story the story to wrap
-    def initialize(story, options = {})
-      raise "Invalid PivotalTracker::Story" if story.nil?
-      @story = story
+    # @param [Project] project the Project for this repo
+    # @param [PivotalTracker::Story] pivotal_story the Pivotal tracker story to wrap
+    def initialize(project, pivotal_story, options = {})
+      raise "Invalid PivotalTracker::Story" if pivotal_story.nil?
+      @project = project
+      @pivotal_story = pivotal_story
       @branch_name = options.delete(:branch_name)
       @branch_suffix = @branch_name.split('-').last if @branch_name
       @branch_suffix ||= nil
     end
 
     def release?
-      story.story_type == 'release'
+      story_type == 'release'
     end
 
     def unestimated?
@@ -63,22 +65,22 @@ module GithubPivotalFlow
     end
 
     def request_estimation!
-      self.story.update(
-        :estimate => ask('Story is not yet estimated. Please estimate difficulty: ')
+      self.update(
+        estimate: ask('Story is not yet estimated. Please estimate difficulty: ')
       )
     end
 
     def mark_started!
       print 'Starting story on Pivotal Tracker... '
-      self.story.update(
-          :current_state => 'started',
-          :owned_by => Git.get_config('user.name', :inherited)
+      self.update(
+          current_state: 'started',
+          owned_by: Git.get_config(KEY_USER_NAME, :inherited).strip
       )
       puts 'OK'
     end
 
     def create_branch!(commit_message = nil, options = {})
-      commit_message ||= "Starting [#{story.story_type} ##{story.id}]: #{story.name}"
+      commit_message ||= "Starting [#{story_type} ##{id}]: #{name}"
       commit_message << " [ci skip]" unless options[:run_ci]
       print "Creating branch for story with branch name #{branch_name} from #{root_branch_name}... "
       Git.checkout(root_branch_name)
@@ -94,32 +96,44 @@ module GithubPivotalFlow
 
     def merge_to_root!(commit_message = nil, options = {})
       commit_message ||= "Merge #{branch_name} to #{root_branch_name}"
-      commit_message << "\n\n[#{options[:no_complete] ? '' : 'Completes '}##{story.id}] "
+      commit_message << "\n\n[#{options[:no_complete] ? '' : 'Completes '}##{id}] "
       print "Merging #{branch_name} to #{root_branch_name}... "
       Git.checkout(root_branch_name)
       Git.pull_remote(root_branch_name)
-      Git.merge(branch_name, commit_message: commit_message, no_ff: true)
-      self.delete_branch!
+      if trivial_merge?
+        Git.merge(branch_name, commit_message: commit_message, ff: true)
+      else
+        Git.merge(branch_name, commit_message: commit_message, no_ff: true)
+      end
       Git.push(root_branch_name)
+      self.delete_branch!
       self.cleanup!
     end
 
     def merge_release!(commit_message = nil, options = {})
-      commit_message ||= "Release #{story.name}"
-      commit_message << "\n\n[#{options[:no_complete] ? '' : 'Completes '}##{story.id}] "
+      commit_message ||= "Release #{name}"
+      commit_message << "\n\n[#{options[:no_complete] ? '' : 'Completes '}##{id}] "
       print "Merging #{branch_name} to #{master_branch_name}... "
       Git.checkout(master_branch_name)
       Git.pull_remote(master_branch_name)
-      Git.merge(master_branch_name, commit_message: commit_message, no_ff: true)
-      Git.tag(story.name)
-      print "Merging #{branch_name} to #{root_branch_name}... "
-      Git checkout(root_branch_name)
-      Git.pull_remote(root_branch_name)
-      Git.merge(branch_name, commit_message: commit_message, no_ff: true)
+      if trivial_merge?(master_branch_name)
+        Git.merge(branch_name, commit_message: commit_message, ff: true)
+      else
+        Git.merge(branch_name, commit_message: commit_message, no_ff: true)
+      end
+      Git.tag(name)
+      print "Merging #{branch_name} to #{development_branch_name}... "
+      Git checkout(development_branch_name)
+      Git.pull_remote(development_branch_name)
+      if trivial_merge?(development_branch_name)
+        Git.merge(branch_name, commit_message: commit_message, ff: true)
+      else
+        Git.merge(branch_name, commit_message: commit_message, no_ff: true)
+      end
       Git.checkout(master_branch_name)
-      self.delete_branch!
-      Git.push(master_branch_name, root_branch_name)
+      Git.push(master_branch_name, development_branch_name)
       Git.push_tags
+      self.delete_branch!
       self.cleanup!
     end
 
@@ -138,17 +152,17 @@ module GithubPivotalFlow
     #end
 
     def branch_name
-      @branch_name ||= branch_name_from(branch_prefix, story.id, branch_suffix)
+      @branch_name ||= branch_name_from(branch_prefix, id, branch_suffix)
     end
 
     def branch_suffix
-      @branch_suffix ||= ask("Enter branch name (#{branch_name_from(branch_prefix, story.id, "<branch-name>")}): ")
+      @branch_suffix ||= ask("Enter branch name (#{branch_name_from(branch_prefix, id, "<branch-name>")}): ")
     end
 
     def branch_name_from(branch_prefix, story_id, branch_name)
       if story_type == 'release'
         # For release branches the format is release/5.0
-        "#{Git.get_config('gitflow.prefix.release', :inherited)}#{branch_name}"
+        "#{Git.get_config(KEY_RELEASE_PREFIX, :inherited)}#{branch_name}"
       else
         n = "#{branch_prefix}#{story_id}"
         n << "-#{branch_name}" unless branch_name.blank?
@@ -168,42 +182,43 @@ module GithubPivotalFlow
     end
 
     def master_branch_name
-      Git.get_config('gitflow.branch.master', :inherited)
+      Git.get_config(KEY_MASTER_BRANCH, :inherited)
     end
 
     def development_branch_name
-      Git.get_config('gitflow.branch.develop', :inherited)
+      Git.get_config(KEY_DEVELOPMENT_BRANCH, :inherited)
     end
 
     def labels
-      return [] if story.labels.blank?
-      story.labels.split(',').collect(&:strip)
+      return [] if pivotal_story.labels.blank?
+      pivotal_story.labels.split(',').collect(&:strip)
     end
 
     def params_for_pull_request
       {
-        :base => root_branch_name,
-        :head => branch_name,
-        :title => name,
-        :body => description,
+        base: root_branch_name,
+        head: branch_name,
+        title: name,
+        body: description,
       }
     end
 
     def method_missing(m, *args, &block)
-      return @story.send(m, *args, &block)
+      return @pivotal_story.send(m, *args, &block)
     end
 
     def can_merge?
-      print "Checking for trivial merge from #{branch_name} to #{root_branch_name}... "
-      Git.pull_remote(root_branch_name)
-      root_tip = Shell.exec "git rev-parse #{root_branch_name}"
-      common_ancestor = Shell.exec "git merge-base #{root_branch_name} #{branch_name}"
+      Git.clean_working_tree?
+    end
 
+    def trivial_merge?(to_branch = nil)
+      to_branch ||= root_branch_name
+      root_tip = Shell.exec "git rev-parse #{to_branch}"
+      common_ancestor = Shell.exec "git merge-base #{to_branch} #{branch_name}"
       if root_tip != common_ancestor
-        abort 'FAIL'
+        return false
       end
-
-      puts 'OK'
+      return true
     end
 
     private
@@ -260,16 +275,18 @@ module GithubPivotalFlow
     end
 
     def branch_prefix
-      case self.story_type
+      case story_type
       when 'feature'
-        Git.get_config('gitflow.prefix.feature', :inherited)
+        prefix = Git.get_config(KEY_FEATURE_PREFIX, :inherited)
       when 'bug'
-        self.labels.include?('hotfix') ? Git.get_config('gitflow.prefix.hotfix', :inherited) : Git.get_config('gitflow.prefix.feature', :inherited)
+        prefix = labels.include?('hotfix') ? Git.get_config(KEY_HOTFIX_PREFIX, :inherited) : Git.get_config(KEY_FEATURE_PREFIX, :inherited)
       when 'release'
-        Git.get_config('gitflow.prefix.release', :inherited)
+        prefix = Git.get_config(KEY_RELEASE_PREFIX, :inherited)
       else
-        'misc/'
+        prefix = 'misc/'
       end
+      prefix = "#{prefix.strip}/" unless prefix.strip[-1,1] == '/'
+      return prefix.strip
     end
   end
 end

data/lib/github_pivotal_flow/version.rb

@@ -0,0 +1,3 @@
+module GithubPivotalFlow
+  VERSION = '0.0.9'
+end

data/spec/github_pivotal_flow/command_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module GithubPivotalFlow
+  describe Command do
+    before do
+      $stdout = StringIO.new
+      $stderr = StringIO.new
+      @configuration = double('configuration')
+      @project = double('project')
+      allow(Configuration).to receive(:new).and_return(@configuration)
+      allow(PivotalTracker::Project).to receive(:find).and_return(@project)
+      @configuration.stub(
+        validate: true,
+        project_id: 123456,
+        project: @project,
+      )
+    end
+
+    describe '#initialize' do
+      it 'validates the configuration when started' do
+        expect(@configuration).to receive(:validate).once
+        @start = Command.new
+      end
+
+      it 'finds the project corresponding to the current repo' do
+        expect(@configuration).to receive(:project).once.and_return(@project)
+        @start = Command.new
+      end
+    end
+  end
+end

data/spec/github_pivotal_flow/configuration_spec.rb

@@ -7,105 +7,116 @@ module GithubPivotalFlow
       $stdout = StringIO.new
       $stderr = StringIO.new
       @configuration = Configuration.new
+      @project = double('project')
     end
 
-    it 'does not prompt the user for the API token if it is already configured' do
-      Git.should_receive(:get_config).with('pivotal.api-token', :inherited).and_return('test_api_token')
+    describe '#validate' do
 
-      api_token = @configuration.api_token
-
-      expect(api_token).to eq('test_api_token')
     end
 
-    it 'prompts the user for the API token if it is not configured' do
-      Git.should_receive(:get_config).with('pivotal.api-token', :inherited).and_return('')
-      @configuration.should_receive(:ask).and_return('test_api_token')
-      Git.should_receive(:set_config).with('pivotal.api-token', 'test_api_token', :global)
-      api_token = @configuration.api_token
-      expect(api_token).to eq('test_api_token')
-    end
+    describe '#api_token' do
+      it 'does not prompt the user for the API token if it is already configured' do
+        Git.should_receive(:get_config).with('pivotal.api-token', :inherited).and_return('test_api_token')
 
-    it 'does not prompt the user for the project id if it is already configured' do
-      Git.should_receive(:get_config).with('pivotal.project-id', :inherited).and_return('test_project_id')
-      project_id = @configuration.project_id
-      expect(project_id).to eq('test_project_id')
+        api_token = @configuration.api_token
+
+        expect(api_token).to eq('test_api_token')
+      end
+
+      it 'prompts the user for the API token if it is not configured and stores it in the local git config' do
+        Git.should_receive(:get_config).with('pivotal.api-token', :inherited).and_return('')
+        @configuration.should_receive(:ask).and_return('test_api_token')
+        Git.should_receive(:set_config).with('pivotal.api-token', 'test_api_token', :local)
+        api_token = @configuration.api_token
+        expect(api_token).to eq('test_api_token')
+      end
     end
 
-    it 'prompts the user for the API token if it is not configured' do
-      Git.should_receive(:get_config).with('pivotal.project-id', :inherited).and_return('')
-      menu = double('menu')
-      menu.should_receive(:prompt=)
-      PivotalTracker::Project.should_receive(:all).and_return([
-                                                                  PivotalTracker::Project.new(:id => 'id-2', :name => 'name-2'),
-                                                                  PivotalTracker::Project.new(:id => 'id-1', :name => 'name-1')])
-      menu.should_receive(:choice).with('name-1')
-      menu.should_receive(:choice).with('name-2')
-      @configuration.should_receive(:choose) { |&arg| arg.call menu }.and_return('test_project_id')
-      Git.should_receive(:set_config).with('pivotal.project-id', 'test_project_id', :local)
-
-      project_id = @configuration.project_id
-
-      expect(project_id).to eq('test_project_id')
+    describe '#project_id' do
+      it 'does not prompt the user for the project id if it is already configured' do
+        Git.should_receive(:get_config).with('pivotal.project-id', :inherited).and_return('test_project_id')
+        project_id = @configuration.project_id
+        expect(project_id).to eq('test_project_id')
+      end
+
+      it 'prompts the user for the project id if it is not configured' do
+        Git.should_receive(:get_config).with('pivotal.project-id', :inherited).and_return('')
+        menu = double('menu')
+        menu.should_receive(:prompt=)
+        PivotalTracker::Project.should_receive(:all).and_return([
+                                                                    PivotalTracker::Project.new(:id => 'id-2', :name => 'name-2'),
+                                                                    PivotalTracker::Project.new(:id => 'id-1', :name => 'name-1')])
+        menu.should_receive(:choice).with('name-1')
+        menu.should_receive(:choice).with('name-2')
+        @configuration.should_receive(:choose) { |&arg| arg.call menu }.and_return('test_project_id')
+        Git.should_receive(:set_config).with('pivotal.project-id', 'test_project_id', :local)
+
+        project_id = @configuration.project_id
+
+        expect(project_id).to eq('test_project_id')
+      end
     end
 
-    it 'persists the story when requested' do
-      Git.should_receive(:set_config).with('pivotal-story-id', 12345678, :branch)
+    describe '#story=' do
+      it 'persists the story when requested' do
+        expect(Git).to receive(:set_config).with('pivotal-story-id', 12345678, :branch)
 
-      @configuration.story = Story.new(PivotalTracker::Story.new(:id => 12345678))
+        @configuration.story = Story.new(@project, PivotalTracker::Story.new(:id => 12345678))
+      end
     end
 
-    describe 'story' do
+    describe '#story' do
+      let(:project) { double('project') }
+      let(:stories) { double('stories') }
+      let(:pivotal_story) { double('pivotal_story') }
+
+      before do
+        allow(@configuration).to receive(:project).and_return(project)
+      end
+
       it 'fetches the story based on the story id stored inside the git config' do
-        project = double('project')
-        stories = double('stories')
-        story = double('story')
-        Git.should_receive(:get_config).with('pivotal-story-id', :branch).and_return('12345678')
-        project.should_receive(:stories).and_return(stories)
-        stories.should_receive(:find).with(12345678).and_return(story)
+        expect(Git).to receive(:get_config).with('pivotal-story-id', :branch).and_return('12345678')
+        expect(project).to receive(:stories).and_return(stories)
+        expect(stories).to receive(:find).with(12345678).and_return(pivotal_story)
 
-        result = @configuration.story project
+        result = @configuration.story
+        expect(result).to be_a(Story)
 
-        expect(result.story).to eq(story)
+        expect(result.pivotal_story).to eq(pivotal_story)
       end
 
       it 'uses the branch name to deduce the story id if no git config is found' do
-        project = double('project')
-        stories = double('stories')
-        story = double('story')
         Git.stub(:current_branch).and_return('feature/12345678-sample_feature')
-        Git.should_receive(:get_config).with('pivotal-story-id', :branch).and_return(' ')
-        project.should_receive(:stories).and_return(stories)
-        stories.should_receive(:find).with(12345678).and_return(story)
+        expect(Git).to receive(:get_config).with('pivotal-story-id', :branch).and_return(' ')
+        expect(project).to receive(:stories).and_return(stories)
+        expect(stories).to receive(:find).with(12345678).and_return(pivotal_story)
 
-        result = @configuration.story project
+        result = @configuration.story
 
-        expect(result.story).to eq(story)
+        expect(result.pivotal_story).to eq(pivotal_story)
       end
 
       it 'prompts for the story id if the branch name does not match the known format' do
-        project = double('project')
-        stories = double('stories')
-        story = double('story')
         Git.stub(:current_branch).and_return('unknownformat')
-        Git.should_receive(:get_config).with('pivotal-story-id', :branch).and_return(' ')
-        @configuration.should_receive(:ask).and_return('12345678')
-        Git.should_receive(:set_config).with('pivotal-story-id', '12345678', :branch)
-        project.should_receive(:stories).and_return(stories)
-        stories.should_receive(:find).with(12345678).and_return(story)
+        expect(Git).to receive(:get_config).with('pivotal-story-id', :branch).and_return(' ')
+        expect(@configuration).to receive(:ask).and_return('12345678')
+        expect(Git).to receive(:set_config).with('pivotal-story-id', '12345678', :branch)
+        expect(project).to receive(:stories).and_return(stories)
+        expect(stories).to receive(:find).with(12345678).and_return(pivotal_story)
 
-        result = @configuration.story project
+        result = @configuration.story
 
-        expect(result.story).to eq(story)
+        expect(result.pivotal_story).to eq(pivotal_story)
       end
     end
 
-    describe 'github_project' do
+    describe '#project' do
       it 'supports working with git urls from the configuration' do
         Git.should_receive(:get_remote).and_return('origin')
         Git.should_receive(:get_config).with('remote.origin.url').and_return('git@github.com:roomorama/github-pivotal-flow.git')
-        github_project = @configuration.github_project
-        expect(github_project.owner).to eq('roomorama')
-        expect(github_project.name).to eq('github-pivotal-flow')
+        project = @configuration.project
+        expect(project.owner).to eq('roomorama')
+        expect(project.name).to eq('github-pivotal-flow')
       end
     end
   end

data/spec/github_pivotal_flow/finish_spec.rb

@@ -18,11 +18,15 @@ module GithubPivotalFlow
           release_prefix: 'release/',
           api_token: 'token',
           project_id: '123',
-          story: @story)
-      allow(Git).to receive(:repository_root)
+          project: @project,
+          github_client: @ghclient,
+          story: @story,
+          validate: true,
+      )
       allow(Configuration).to receive(:new).and_return(@configuration)
-      allow(PivotalTracker::Project).to receive(:find).and_return(@project)
+      allow(Project).to receive(:find).and_return(@project)
       @finish = Finish.new
+      expect(@configuration).to receive(:story).and_return(@story)
     end
 
     it 'merges the branch back to its root by default' do

data/spec/github_pivotal_flow/git_spec.rb

@@ -112,7 +112,7 @@ module GithubPivotalFlow
           expect(File).to receive(:exist?).with(hook).and_return(true)
 
           Git.add_hook 'prepare-commit-msg', __FILE__
-          expect(File).to receive(:exist?).and_call_original
+          allow(File).to receive(:exist?).and_call_original
           expect(File.exist?(hook)).to be_false
         end
       end

data/spec/github_pivotal_flow/start_spec.rb

@@ -5,9 +5,11 @@ module GithubPivotalFlow
     before do
       $stdout = StringIO.new
       $stderr = StringIO.new
-
-      @project = double('project')
       @story = double('story')
+      @project = double('project')
+      @project.stub(
+          stories: [@story]
+      )
       @ghclient = double('ghclient')
       @ghproject = double('ghproject')
       @configuration = double('configuration')
@@ -19,16 +21,17 @@ module GithubPivotalFlow
           release_prefix: 'release/',
           api_token: 'token',
           project_id: '123',
-          github_project: @ghproject,
-          story: @story)
-      allow(Git).to receive(:repository_root)
-      allow(GitHubAPI).to receive(:new).and_return(@ghclient)
+          project: @project,
+          github_client: @ghclient,
+          story: @story,
+          validate: true,
+      )
       allow(Configuration).to receive(:new).and_return(@configuration)
       allow(PivotalTracker::Project).to receive(:find).and_return(@project)
       @start = Start.new()
     end
 
-    it 'should run' do
+    it 'should runs correctly' do
       @start.options[:args] = 'test_filter'
       @story.stub(:unestimated? => false, :release? => false, params_for_pull_request: {})
 

data/spec/github_pivotal_flow/story_spec.rb

@@ -10,7 +10,10 @@ module GithubPivotalFlow
       @project = double('project')
       @stories = double('stories')
       @story = double('story')
+      @pivotal_story = double('pivotal_story')
       @menu = double('menu')
+      allow(@project).to receive(:stories).and_return(@stories)
+      allow(@story).to receive(:pivotal_story).and_return(@pivotal_story)
     end
 
     describe '.pretty_print' do
@@ -59,32 +62,28 @@ module GithubPivotalFlow
 
     describe '.select_story' do
       it 'selects a story directly if the filter is a number' do
-        @project.should_receive(:stories).and_return(@stories)
-        @stories.should_receive(:find).with(12345678).and_return(@story)
-
+        expect(@stories).to receive(:find).with(12345678).and_return(@pivotal_story)
         story = Story.select_story @project, '12345678'
 
         expect(story).to be_a(Story)
-        expect(story.story).to be(@story)
+        expect(story.pivotal_story).to eq(@pivotal_story)
       end
 
       it 'selects a story if the result of the query is a single story' do
-        @project.should_receive(:stories).and_return(@stories)
-        @stories.should_receive(:all).with(
+        expect(@stories).to receive(:all).with(
             :current_state => %w(rejected unstarted unscheduled),
             :limit => 1,
             :story_type => 'release'
-        ).and_return([@story])
+        ).and_return([@pivotal_story])
 
         story = Story.select_story @project, 'release', 1
 
         expect(story).to be_a(Story)
-        expect(story.story).to be(@story)
+        expect(story.pivotal_story).to eq(@pivotal_story)
       end
 
       it 'prompts the user for a story if the result of the query is more than a single story' do
-        @project.should_receive(:stories).and_return(@stories)
-        @stories.should_receive(:all).with(
+        expect(@stories).to receive(:all).with(
             :current_state => %w(rejected unstarted unscheduled),
             :limit => 5,
             :story_type => 'feature'
@@ -92,66 +91,77 @@ module GithubPivotalFlow
                          PivotalTracker::Story.new(:name => 'name-1'),
                          PivotalTracker::Story.new(:name => 'name-2')
                      ])
-        @menu.should_receive(:prompt=)
-        @menu.should_receive(:choice).with('name-1')
-        @menu.should_receive(:choice).with('name-2')
-        Story.should_receive(:choose) { |&arg| arg.call @menu }.and_return(@story)
+        expect(@menu).to receive(:prompt=)
+        expect(@menu).to receive(:choice).with('name-1')
+        expect(@menu).to receive(:choice).with('name-2')
+        expect(Story).to receive(:choose) { |&arg| arg.call @menu }.and_return(@pivotal_story)
 
         story = Story.select_story @project, 'feature'
 
         expect(story).to be_a(Story)
-        expect(story.story).to be(@story)
+        expect(story.pivotal_story).to eq(@pivotal_story)
       end
 
       it 'prompts the user with the story type if no filter is specified' do
-        @project.should_receive(:stories).and_return(@stories)
-        @stories.should_receive(:all).with(
+        expect(@stories).to receive(:all).with(
             :current_state => %w(rejected unstarted unscheduled),
             :limit => 5
         ).and_return([
                          PivotalTracker::Story.new(:story_type => 'chore', :name => 'name-1'),
                          PivotalTracker::Story.new(:story_type => 'bug', :name => 'name-2')
                      ])
-        @menu.should_receive(:prompt=)
-        @menu.should_receive(:choice).with('CHORE   name-1')
-        @menu.should_receive(:choice).with('BUG     name-2')
-        Story.should_receive(:choose) { |&arg| arg.call @menu }.and_return(@story)
+        expect(@menu).to receive(:prompt=)
+        expect(@menu).to receive(:choice).with('CHORE   name-1')
+        expect(@menu).to receive(:choice).with('BUG     name-2')
+        expect(Story).to receive(:choose) { |&arg| arg.call @menu }.and_return(@pivotal_story)
 
         story = Story.select_story @project
 
         expect(story).to be_a(Story)
-        expect(story.story).to be(@story)
+        expect(story.pivotal_story).to eq(@pivotal_story)
       end
     end
 
     describe '#create_branch!' do
       before do
-        @story.stub(story_type: 'feature', id: '123456', name: 'test', description: 'description')
-        @pstory = GithubPivotalFlow::Story.new(@story)
-        allow(@pstory).to receive(:ask).and_return('test')
+        Git.stub(
+          checkout: nil,
+          pull_remote: nil,
+          create_branch: nil,
+          set_config: nil,
+          get_config: nil,
+          push: nil,
+          commit: nil,
+          get_remote: 'origin',
+        )
+        @pivotal_story.stub(
+            story_type: 'feature',
+            id: '123456',
+            name: 'test',
+            description: 'description')
+        @story = GithubPivotalFlow::Story.new(@project, @pivotal_story)
+        allow(@story).to receive(:ask).and_return('test')
       end
 
       it 'prompts the user for a branch extension name' do
-        Git.stub(checkout: nil, pull_remote: nil, create_branch: nil, set_config: nil, push: nil, commit: nil)
-        expect(@pstory).to receive(:ask).with("Enter branch name (123456-<branch-name>): ").and_return('super-branch')
+        allow(@story).to receive(:branch_prefix).and_return('feature/')
+        expect(@story).to receive(:ask).with("Enter branch name (feature/123456-<branch-name>): ").and_return('super-branch')
 
-        @pstory.create_branch!('Message')
+        @story.create_branch!('Message')
       end
 
       it 'includes a tag to skip the ci build for the initial blank commit' do
         @story.stub(branch_name: 'feature/123456-my_branch')
-        Git.stub(checkout: nil, pull_remote: nil, create_branch: nil, set_config: nil, push: nil)
-        Git.should_receive(:commit).with(hash_including(commit_message: 'Message [ci skip]')).and_return(true)
+        expect(Git).to receive(:commit).with(hash_including(commit_message: 'Message [ci skip]')).and_return(true)
 
-        @pstory.create_branch!('Message')
+        @story.create_branch!('Message')
       end
 
       it 'pushes the local branch and sets the upstream using the -u flag' do
         @story.stub(branch_name: 'feature/123456-my_branch')
-        Git.stub(checkout: nil, pull_remote: nil, create_branch: nil, set_config: nil, commit: nil)
-        Git.should_receive(:push).with(instance_of(String), hash_including(set_upstream: true))
+        expect(Git).to receive(:push).with(instance_of(String), hash_including(set_upstream: true))
 
-        @pstory.create_branch!('Message')
+        @story.create_branch!('Message')
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: github-pivotal-flow
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Donald Piret
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-22 00:00:00.000000000 Z
+date: 2014-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -108,20 +108,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
-- !ruby/object:Gem::Dependency
-  name: debugger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -161,20 +147,22 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- bin/git-finish
+- bin/git-start
 - lib/core_ext/object/blank.rb
+- lib/github_pivotal_flow.rb
 - lib/github_pivotal_flow/command.rb
 - lib/github_pivotal_flow/configuration.rb
 - lib/github_pivotal_flow/finish.rb
 - lib/github_pivotal_flow/git.rb
 - lib/github_pivotal_flow/github_api.rb
+- lib/github_pivotal_flow/prepare-commit-msg.sh
 - lib/github_pivotal_flow/project.rb
 - lib/github_pivotal_flow/shell.rb
 - lib/github_pivotal_flow/start.rb
 - lib/github_pivotal_flow/story.rb
-- lib/github_pivotal_flow.rb
-- lib/github_pivotal_flow/prepare-commit-msg.sh
-- bin/git-finish
-- bin/git-start
+- lib/github_pivotal_flow/version.rb
+- spec/github_pivotal_flow/command_spec.rb
 - spec/github_pivotal_flow/configuration_spec.rb
 - spec/github_pivotal_flow/finish_spec.rb
 - spec/github_pivotal_flow/git_spec.rb
@@ -201,11 +189,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Git commands for integration with Pivotal Tracker and Github pull requests
 test_files:
+- spec/github_pivotal_flow/command_spec.rb
 - spec/github_pivotal_flow/configuration_spec.rb
 - spec/github_pivotal_flow/finish_spec.rb
 - spec/github_pivotal_flow/git_spec.rb