git_workflow 0.0.5

data/lib/git_workflow/commands/setup.rb

@@ -0,0 +1,157 @@
+require 'highline'
+
+class HighLine
+  [ :ask, :choose ].each do |name|
+    eval <<-END_OF_METHOD_ALIASING
+      def #{ name }_with_newline(*args, &block)
+        #{ name }_without_newline(*args, &block)
+      ensure
+        $stdout.puts
+      end
+      alias_method_chain(:#{ name }, :newline)
+    END_OF_METHOD_ALIASING
+  end
+end
+
+class HighLine::Menu
+  def menu_option(menu_text, result)
+    choice(menu_text) { result }
+  end
+end
+
+module GitWorkflow
+  module Commands
+    class Setup < Base
+      def execute
+        [ :name, :token, :project_id, :workflow, :branches ].each do |step|
+          send(:"enquire_about_#{ step }")
+        end
+      end
+
+    private
+
+      ALIGNMENT_PADDING = ' ' * 10
+
+      def usage_info(options)
+        options.banner = 'Usage: git workflow-setup'
+      end
+
+      def highline
+        @highline ||= HighLine.new
+      end
+
+      delegate :get_config_value_for, :to => 'GitWorkflow::Configuration.instance'
+      delegate :set_config_value, :to => 'GitWorkflow::Configuration.instance'
+
+      def set_value_through(method, setting, *args, &block)
+        options  = args.last.is_a?(Hash) ? args.pop : {}
+        optional = options.delete(:optional)
+
+        # Only update the value if it is set or is optional and blank.
+        default = get_config_value_for(setting)
+        value   = highline.send(method, *args) do |question|
+          question.default = default
+          block.call(question)
+        end
+        set_config_value(setting, value) unless optional and value.blank?
+      end
+
+      def ask(setting, options = {}, &block)
+        set_value_through(:ask, setting, 'Dummy', options, &block)
+      end
+
+      def choose(setting, options = {}, &block)
+        set_value_through(:choose, setting, options, &block)
+      end
+
+      def enquire_about_name
+        username = get_config_value_for('user.name')
+        ask('pt.username', :optional => true) do |question|
+          text = %Q{
+            When marking Pivotal Tracker (http://pivotaltracker.com/) stories as started or finished,
+            this git workflow needs to know your name.  You have to enter it as it appears on 
+            Pivotal Tracker and it is your name, not your email address.  For instance, I appear 
+            as 'Matthew Denner'.
+          }
+          text << %Q{
+            If the name you have on Pivotal Tracker is the same as the current git 'user.name' then
+            you can leave this blank.  Your git 'user.name' is currently: #{ username }
+          } unless username.blank?
+          text << %Q{
+            Please enter your Pivotal Tracker name:
+          }
+
+          question.question = text.align(ALIGNMENT_PADDING)
+          question.default  = ''
+        end
+      end
+
+      def enquire_about_token
+        ask('pt.token') do |question|
+          question.validate = /^[A-Fa-f0-9]{32}$/ 
+          question.question = %Q{
+            When the workflow starts or finishes a story it needs to be able to interact with Pivotal
+            Tracker (http://pivotaltracker.com/) and to do so you must have an account.  Any updates
+            this git workflow makes to Pivotal Tracker need to be done through the API and so it needs
+            to know your individual API token.  This can be found under 'API Token' on your profile
+            page (https://www.pivotaltracker.com/profile).
+
+            Please enter your Pivotal Tracker API token:
+          }.align(ALIGNMENT_PADDING)
+        end
+      end
+
+      def enquire_about_project_id
+        ask('pt.projectid') do |question|
+          question.answer_type = Integer
+          question.question    = %Q{
+            To interact with Pivotal Tracker (http://pivotaltracker.com/) this git workflow needs to
+            know the ID for your project.  This can be found in the URL you get when looking at your
+            project and is the numeric valid after 'http://www.pivotaltracker.com/projects'.
+
+            Please enter your Pivotal Tracker project ID:
+          }.align(ALIGNMENT_PADDING)
+        end
+      end
+
+      def enquire_about_workflow
+        ask('workflow.callbacks') do |question|
+          question.default  = 'default'
+          question.question = %Q{
+            The standard behaviour of this git workflow is to create a new branch and mark a 
+            Pivotal Tracker (http://pivotaltracker.com/) story as started when you run 'git start',
+            and to mark a Pivotal Tracker story as finished when you run 'git finish'.  You can alter
+            this behaviour by choosing a different workflow.
+
+            Please enter the name of your workflow:
+          }.align(ALIGNMENT_PADDING)
+        end
+      end
+
+      def enquire_about_branches
+        choose_branch_convention(:local)
+        choose_branch_convention(:remote)
+      end
+
+      def choose_branch_convention(location)
+        choose("workflow.#{ location }branchconvention") do |convention|
+          convention.header = %Q{
+            Git branches are created locally and can be pushed remotely.  The naming convention for these
+            can be different and can be setup to your personal preference.  It's easier to explain their
+            format with an example:
+
+            Imagine you have story 12345 which has a title of 'Do something useful'.  If you choose to have
+            a branch convention of "PT story number, then PT story title" the branch created will be
+            '12345_do_something_useful'.  If you select "PT story title, then PT story number" you will
+            get the branch 'do_something_useful_12345'.
+          }.align(ALIGNMENT_PADDING)
+
+          convention.menu_option('PT story number, then PT story title', '${number}_${name}')
+          convention.menu_option('PT story title, then PT story number', '${name}_${number}')
+
+          convention.prompt = "Choose your #{ location } branch naming convention:"
+        end
+      end
+    end
+  end
+end

data/lib/git_workflow/commands/start.rb

@@ -0,0 +1,30 @@
+require 'git_workflow/commands/base'
+
+module GitWorkflow
+  module Commands
+    class Start < Base
+      def initialize(command_line_arguments)
+        super(command_line_arguments) do |remaining_arguments|
+          @story_id, @parent_branch = remaining_arguments
+          raise InvalidCommandLine, 'The command line is invalid' if @story_id.nil?
+        end
+      end
+
+      def execute
+        story(@story_id) do |story|
+          start(story, @parent_branch)
+          start_story_on_pivotal_tracker!(story)
+  
+          $stdout.puts "Story #{ story.story_id }: #{ story.name }"
+          $stdout.puts story.description
+        end
+      end
+
+    private
+
+      def usage_info(options)
+        options.banner = 'Usage: git start <PT story number> [<parent branch>]'
+      end
+    end
+  end
+end

data/lib/git_workflow/configuration.rb

@@ -0,0 +1,93 @@
+require 'singleton'
+require 'git_workflow/git'
+
+module GitWorkflow
+  class Configuration
+    include Singleton
+    include GitWorkflow::Git
+
+    class Convention
+      include GitWorkflow::Git
+
+      REGEXP_STORY_ID   = /\$\{\s*number\s*\}/
+      REGEXP_EVALUATION = /\$\{(number|name)\}/
+
+      def initialize(convention)
+        raise StandardError, "Convention '#{ convention }' has no story ID" unless convention =~ REGEXP_STORY_ID
+        @to_convention   = convention.gsub(REGEXP_EVALUATION, '#{\1}')
+        @from_convention = Regexp.new(convention.sub(REGEXP_STORY_ID, '(\d+)').gsub(REGEXP_EVALUATION, '.+'))
+      end
+
+      def to(story)
+        use_existing_branch_for(story) || generate_new_branch_name_for(story)
+      end
+
+      def from(branch)
+        match = branch.match(@from_convention)
+        raise StandardError, "Branch '#{ branch }' does not appear to conform to local convention" if match.nil?
+        match[ 1 ].to_i
+      end
+
+    private
+
+      def use_existing_branch_for(story)
+        repository.branches.detect do |branch|
+          begin
+            from(branch) == story.story_id
+          rescue StandardError => exception
+            # Ignore, as this is definitely not the branch!
+            false
+          end
+        end
+      end
+
+      def generate_new_branch_name_for(story)
+        StoryWrapper.new(story).__instance_eval__(%Q{"#{ @to_convention }"}).downcase.gsub(/[^a-z0-9]+/, '_').sub(/_+$/, '')
+      end
+
+      class StoryWrapper
+        alias_method :__instance_eval__, :instance_eval
+        instance_methods.each do |method|
+          undef_method(method) unless method.to_s =~ /^__(send|id|instance_eval)__$/
+        end
+
+        def initialize(story)
+          @story = story
+        end
+
+        def number
+          @story.story_id
+        end
+
+        def name
+          @story.name
+        end
+      end
+
+    end
+
+    def username
+      @username ||= get_config_value_for('pt.username') || get_config_value_for!('user.name')
+    end
+
+    def local_branch_convention
+      @local_branch_convention ||= Convention.new(get_config_value_for!('workflow.localbranchconvention'))
+    end
+
+    def remote_branch_convention
+      @remote_branch_convention ||= Convention.new(get_config_value_for!('workflow.remotebranchconvention'))
+    end
+
+    def project_id
+      @project_id ||= get_config_value_for!('pt.projectid')
+    end
+
+    def api_token
+      @api_token ||= get_config_value_for!('pt.token')
+    end
+
+    def ignore_git_global?
+      ENV['IGNORE_GIT_GLOBAL']
+    end
+  end
+end

data/lib/git_workflow/core_ext.rb

@@ -0,0 +1,106 @@
+class Class
+  def delegates_to_class(method)
+    class_eval do
+      linenumber = __LINE__ + 1
+      eval(%Q{
+        def #{ method }(*args, &block)
+          self.class.#{ method }(*args, &block)
+        end
+      }, binding, __FILE__, linenumber)
+    end
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class String
+  def blank?
+    self =~ /^\s*$/
+  end
+
+  def underscore
+    self.split('::').map { |v| v.gsub(/(.)([A-Z])/, '\1_\2') }.join('/').downcase
+  end
+
+  def camelize
+    self.split('/').map { |v| v.gsub(/(?:^|_)(.)/) { $1.upcase } }.join('::')
+  end
+
+  def constantize
+    self.camelize.split('::').inject(Object) do |current,constant|
+      current.const_get(constant) or current.const_missing(constant)
+    end
+  end
+
+  def align(padding = '')
+    self.gsub(/^\s+([^\s])/, "#{ padding }\\1")
+  end
+end
+
+require 'popen4'
+
+module Execution
+  class CommandFailure < StandardError
+    attr_reader :result
+
+    def initialize(command, result)
+      super("Command '#{ command }' failed")
+      @result = result
+    end
+
+    def raise_if_required!
+      raise self unless @result.exitstatus == 0
+    end
+  end
+
+  def execute_command(command)
+    command_output = nil
+    execute_command_with_output_handling(command) { |stdout, _, _| command_output = stdout.read }
+    command_output
+  end
+
+  def execute_command_with_output_handling(command, &block)
+    debug("Executing '#{ command }' ...") do
+      exit_status = POpen4.popen4(command) do |stdout, stderr, stdin, pid|
+        yield(stdout, stderr, stdin)
+      end
+      CommandFailure.new(command, exit_status).raise_if_required!
+    end
+  end
+end
+
+class Module
+  def chain_methods(method, chain, &block)
+    match                  = method.to_s.match(/^([^!\?]+)([!\?])?$/) or raise StandardError, "Cannot match '#{ method }' as a method"
+    method_core, extension = match[ 1 ], match[ 2 ]
+    with_chain_method    = :"#{ method_core }_with_#{ chain }#{ extension }"
+    without_chain_method = :"#{ method_core }_without_#{ chain }#{ extension }"
+    yield(with_chain_method, without_chain_method)
+  end
+
+  def alias_method_chain(method, chain)
+    chain_methods(method, chain) do |with_chain_method, without_chain_method|
+      alias_method(without_chain_method, method)
+      alias_method(method, with_chain_method)
+    end
+  end
+
+  def unalias_method_chain(method, chain)
+    chain_methods(method, chain) do |with_chain_method, without_chain_method|
+      alias_method(method, without_chain_method)
+      undef_method(without_chain_method)
+    end
+  end
+
+  def delegate(name, options)
+    class_eval <<-END_OF_DELEGATION
+      def #{ name }(*args, &block)
+        #{ options[ :to ] }.#{ name }(*args, &block)
+      end
+    END_OF_DELEGATION
+  end
+end

data/lib/git_workflow/git.rb

@@ -0,0 +1,143 @@
+require 'singleton'
+require 'git_workflow/core_ext'
+
+module GitWorkflow
+  module Git
+    class Repository
+      include Singleton
+      include Execution
+      include GitWorkflow::Logging
+
+      RepositoryError = Class.new(StandardError)
+      BranchError     = Class.new(RepositoryError)
+      CheckoutError   = Class.new(RepositoryError)
+      ConfigError     = Class.new(RepositoryError)
+
+      def current_branch
+        return @current_branch unless @current_branch.nil?
+
+        match = execute_command('git branch').match(/\*\s+([^\s]+)/)
+        raise BranchError, 'Could not determine current branch' if match.nil?
+        @current_branch = match[ 1 ]
+      end
+
+      def checkout(branch)
+        maintain_current_branch(branch) do
+          begin
+            info("Checking out branch '#{ branch }'") do
+              execute_command("git checkout #{ branch }")
+            end
+          rescue Execution::CommandFailure => exception
+            raise CheckoutError, "Unable to checkout branch '#{ branch }'"
+          end
+        end
+      end
+
+      def create(branch, source = nil)
+        maintain_current_branch(branch) do
+          begin
+            info("Creating branch '#{ branch }'") do
+              command = "git checkout -b #{ branch }"
+              command << " #{ source }" unless source.nil?
+              execute_command(command)
+            end
+          rescue Execution::CommandFailure => exception
+            raise CheckoutError, "Unable to create branch '#{ branch }'"
+          end
+        end
+      end
+
+      def merge(branch)
+        execute_command("git merge #{ branch }")
+      rescue Execution::CommandFailure => exception
+        raise BranchError, "Could not merge #{ branch } into current branch"
+      end
+
+      def branches
+        execute_command('git branch').split("\n").map { |b| b.sub(/^(\*)?\s+/, '') }
+      end
+
+      def does_branch_exist?(branch)
+        execute_command('git branch') =~ /\s+#{ branch }(\s+|$)/
+      end
+
+      def config_get(key)
+        command  = [ 'git config' ]
+        command << '--file .git/config' if GitWorkflow::Configuration.instance.ignore_git_global?
+        command << key
+        value = execute_command(command.join(' ')).strip
+        value.empty? ? nil : value
+      rescue Execution::CommandFailure => exception
+        raise ConfigError, "Could not retrieve '#{ key }' configuration setting"
+      end
+
+      def config_set(key, value)
+        raise ConfigError, 'No key has been specified for configuration setting' if key.blank?
+        execute_command(%Q{git config '#{ key }' '#{ value }'})
+      rescue Execution::CommandFailure => exception
+        raise ConfigError, "Could not set '#{ key }' configuration setting (value: #{ value })"
+      end
+
+      def push(branch)
+        execute_command("git push origin #{ branch }")
+      rescue Execution::CommandFailure => exception
+        raise BranchError, "Unable to push branch '#{ branch }'"
+      end
+
+    private
+
+      def maintain_current_branch(branch, &block)
+        yield
+        @current_branch = branch
+      end
+    end
+
+    def repository
+      Repository.instance
+    end
+
+    def in_git_branch(target_branch, &block)
+      current_branch = repository.current_branch
+      if current_branch == target_branch
+        yield
+      else
+        info("Temporarily switching to branch '#{ target_branch }'")
+
+        repository.checkout(target_branch)
+        yield
+        repository.checkout(current_branch)
+
+        info("Switched back to '#{ current_branch }'")
+      end
+    end
+
+    def merge_branch(source_branch, target_branch)
+      info("Merging branch '#{ source_branch }' into '#{ target_branch }'") do
+        repository.checkout(target_branch)
+        repository.merge(source_branch)
+      end
+    end
+
+    def checkout_or_create_branch(branch, source = nil)
+      if repository.does_branch_exist?(branch)
+        repository.checkout(branch)
+      else
+        repository.create(branch, source)
+      end
+    end
+
+    def get_config_value_for(key, default = nil)
+      repository.config_get(key)
+    rescue Repository::ConfigError => exception
+      default
+    end
+
+    def get_config_value_for!(key)
+      get_config_value_for(key) or raise StandardError, "Required configuration setting '#{ key }' is unset"
+    end
+
+    def set_config_value(key, value)
+      repository.config_set(key, value)
+    end
+  end
+end