git-process 0.9.5 → 0.9.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    git-process (0.9.5)
+    git-process (0.9.6)
       highline (~> 1.6.12)
       json (~> 1.7.3)
       launchy (~> 2.1.0)

data/README.md

@@ -1,29 +1,25 @@
 [![Build Status](https://secure.travis-ci.org/jdigger/git-process.png)](http://travis-ci.org/jdigger/git-process)
 
-# Purpose and Motivation #
+# Purpose #
+
+This provides an easy way to work with a sane git workflow process that encourages using highly-focussed branches to encourage collaboration, enable fearless changes, and improve team communication.
+
+See the F.A.Q. for a much more complete explanation for the thoughts and assumptions that motivates this project.
 
-This provides an easy way to work with a sane git workflow process.
-Short-lived feature branches can work quite well, but the formal git-flow process can be rather heavy in cost.
 
 # Installation #
 
     $ sudo gem install git-process
 
-## Configurables ##
-See notes for more details
-
-* OAuth2 Token 
-* The name of the integration branch (defaults to `origin/master`, but can be set to `develop` or other)
 
----
 # Overview #
 
 ## Anticipated Use Cases ##
 
-1. User Creates new local branch
-1. User pushes local branch to remote (as feature branch) by rebasing integration branch, then pushing branch to remote
-1. User closes local branch by rebasing integration branch first, then pushing local to integration
-1. User initiates GitHub "pull request"
+1. User creates new local branch for focussed work.
+1. User pushes local branch to remote (as feature branch) by merging/rebasing with the integration branch, then pushing to the branch to remote.
+1. User closes local branch by rebasing integration branch first, then pushing local to integration.
+1. User initiates GitHub "pull request" to ease collaboration.
 
 ## Command List ##
 
@@ -34,6 +30,7 @@ See notes for more details
 
 **All commands are well documented within themselves: Use the "-h" switch to see the full documentation.** (e.g., "`git sync -h`")
 
+
 # Workflow #
 
 _The following assumes that the integration branch is "origin/master"._
@@ -53,6 +50,17 @@ _The following assumes that the integration branch is "origin/master"._
 5. If you still need to make changes, do so and use "`git sync`" to keep your branch on the
    server for that feature updated with your work until all issues have been resolved.
 
+```
+$ git new-fb my-feature      # 1
+# do work                    # 2
+$ git commit                 # 3
+$ git sync                   # 4
+# repeat #2-#4 as necessary  # 5
+$ git pull-request           # 6
+# repeat #2-#4 as necessary  # 7
+$ git to-master              # 8
+```
+
 ## Working Alone or When Pairing ##
 
 1. When starting work on a new feature, use "`git new-fb feature-name`".
@@ -64,31 +72,34 @@ _The following assumes that the integration branch is "origin/master"._
 3. When you are ready to merge your work into the mainline, "`git to-master`".
     * This will merge and push your changes into "`origin/master`"
 
+```
+$ git new-fb my-feature      # 1
+# do work                    # 2
+$ git commit                 # 3
+$ git sync                   # 4
+# repeat #2-#4 as necessary  # 5
+$ git to-master              # 6
+```
+
+
+# Assumptions #
+
+* You should **_never_** do any work directly on "`master`" (or whatever you define the mainline branch as): everything is done on a feature branch.  This is a much safer and more flexible practice than doing everything on the same branch, but may seem odd to people used to old VCSs. In addition to being a much better way of working in general (see the F.A.Q. for more information), it is also a requirement to take advantage of Pull Request functionality.
+* When working on a branch, you should be integrating with "`master`" as often as possible.
+  * "`git sync`" makes it extremely easy for you to get any changes that are made in "`master`" into your branch so you can react to it immediately. "`git to-master`" then makes it easy to cleanly integrate the changes you have made, along with encouraging code-review/sign-off, and doing various house-keeping duties.
+* The process that you use should be essentially the same, regardless of whether you are working alone, or on a large distributed team.
+  * The exception here is "`git pull-request`" since you do not use pull requests when working solo or when pair-programming.
 
 # Notes #
 
-* It's assumed that you **_never_** do any work directly on "`master`": everything is done on a
-  feature branch.  This is a much safer and more flexible practice, but may seem odd to
-  people used to old VCSs. In addition to being a much better way of working in general,
-  it is also a requirement to take advantage of Pull Request functionality.
-    * After publishing changes to the main integration branch (i.e., "`git to-master`") the
-      old feature branch is removed as part of cleanup. Git is then "parked" on a "`_parking_`"
-      branch until a new feature branch is created. Work is not expected to be done on this
-      branch, but any that is done is brought over to a newly created feature branch (i.e.,
-      "`git new-fb`").
-* If there is a problem (such as a merge conflict), this will try to resolve such errors
-  for you as much as it can do safely. When it can't do so in an automated way, it will try
-  to tell you the process for doing so manually.
-* The first time you use a GitHub feature (e.g., "`git pull-request`"), this will ask for your
-  username and password. It does not store them, but instead uses them to get an OAuth2 token,
-  which is stored in "`git config gitProcess.github.authToken`".
-* If you want to use a different integration branch other than "`master`", set the
-  "`gitProcess.integrationBranch`" configuration value. (e.g.,
-  "`git config gitProcess.integrationBranch my-integ-branch`")
+* After publishing changes to the main integration branch (i.e., "`git to-master`") the old feature branch is removed as part of cleanup. Git is then "parked" on a "`_parking_`" branch until a new feature branch is created. Work is not expected to be done on this branch, but any that is done is brought over to a newly created feature branch (i.e., "`git new-fb`").
+* If there is a problem (such as a merge conflict), this will try to resolve such errors for you as much as it can do safely. When it can't do so in an automated way, it will try to tell you the process for doing so manually.
+* The first time you use a GitHub feature (e.g., "`git pull-request`"), this will ask for your username and password. It does not store them, but instead uses them to get an OAuth2 token, which is stored in "`git config gitProcess.github.authToken`".
+* If you want to use a different integration branch other than "`master`", set the "`gitProcess.integrationBranch`" configuration value. (e.g., "`git config gitProcess.integrationBranch my-integ-branch`")
 * This tries to respond "intelligently" to the use of 'rerere'.
 
 
-# FAQ #
+# F.A.Q. #
 
 ## Q: How is this different from git-flow or GitHub flow? ##
 
@@ -101,7 +112,7 @@ _The following assumes that the integration branch is "origin/master"._
 
 Branches are extremely powerful tools that allow for clean organization/modularization of development.
 
-* Branches make it easy to sandbox changes while they are in a state of flux, while at the same time be very fearless about making potentially breaking changes.
+* Branches make it easy to sandbox changes while they are in a state of flux, while at the same time allowing you to be very fearless about making potentially breaking changes.
     * For example, I commit "green to green": Doing [TDD](http://en.wikipedia.org/wiki/Test-driven_development), I commit every time I have a newly passing test case. So, assuming I'm in a regular development flow, I'm committing my changes every five minutes. Tiny commits, but lots of them. What that means is that if I make a "less than wise choice" at some point, it's trivial to rewind to before I'd made the mistake, potentially keep the throw-away code in another branch while I do my cleanup, and generally use the full power of a revision control system to make my life safer and easier. The branch(es) are pretty chaotic, but that's not a problem because before integrating with the mainline, I take a moment to cleanup: Squash related commits together, write clearer commit messages (since now I know what "the answer" is), and generally move from my drafts to a more finished result. (See below on objections related to "lying with rebase.") That may just be me, though, because I'm very paranoid when it comes to computers. I tend to automatically hit Cmd/Ctl-S every time I type a period when I'm writing, or when I close a block when I'm programming. I have a minimum of three copies/backups around the world of all my important documents. And I "`git sync`" frequently to make sure my machine isn't the only place where all my hard work is being stored. Have I mentioned I don't trust computers?
 
 * Branches allow for focused collaboration. Because a branch is about exactly one thing, it means that a team can collaborate around a feature/bug (especially when used in conjunction with a "pull request"), and keep such changes sandboxed until such time that they are ready to bring a larger audience into the mix.
@@ -114,7 +125,7 @@ Making it "easier to do things right than wrong" (i.e., using branches and keepi
 
 ## Q: Why so much emphasis on rebasing? Isn't rebasing a dangerous lie? ##
 
-Like any powerful tool, "`git rebase`" is "dangerous" if used incorrectly, just like "`rm -rf`". You simply need to know when and how to use it safely. And in the world of version control systems, "rebasing" is easily one of the most _**useful**_ tools to come around since the "`commit`" command.
+Like any powerful tool, "`git rebase`" is "dangerous" if used incorrectly, just like "`rm`"/"`del`". You simply need to know when and how to use it safely. And in the world of version control systems, "rebasing" is easily one of the most _**useful**_ tools to come around since the "`commit`" command.
 
 [A famous article](http://paul.stadig.name/2010/12/thou-shalt-not-lie-git-rebase-ammend.html) that people have been parroting in various forms for a while makes the case that rebasing (and its various forms, such as squashing, amending commits, etc.) is a "lie." As with so many things, context is everything.
 
@@ -124,8 +135,14 @@ Rebasing "your" code is an extremely useful way of communicating clearly. In the
 
 If you have ever seen an "active" project that uses a process like "git-flow" that encourages a lot of branching and merging, you've seen how hard it can be to follow a particular line of development. Branch lines are flying around everywhere, and half the commits are pretty much pure noise. (e.g., "Merge branch 'develop' of ... into develop".) It's also hard to follow the order in which commits actually impacted the mainline. In many ways, in practice merges turn into "a truth effectively being a lie (because it's buried in the noise)" versus rebases that are "a lie (changed from it's 'original' form) to tell an effective truth (clean and very clear about its impact)."
 
-I am trying to promote clear communication about current reality over micro-management over no-longer-relevant history. Thus the judicious use of rebase.
+This project is trying to promote clear communication about reality as it applies to the code, over micro-management over no-longer-relevant history. Thus rational for the judicious use of rebase.
+
 
+## Configurables ##
+See notes for more details
+
+* GitHub authentication token
+* The name of the integration branch (defaults to `origin/master`, but can be set to `develop` or other)
 
 # Contributing #
 

data/bin/git-sync

@@ -1,8 +1,13 @@
 #!/usr/bin/env ruby
 
+# require "rubygems"
+# require "bundler/setup"
+# $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+
 require 'git-process/git_process_options'
 require 'git-process/sync'
 
+
 class SyncOptions
   include GitProc::GitProcessOptions
 

data/lib/git-process/changed_file_helper.rb

@@ -0,0 +1,106 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.require 'shellwords'
+
+require 'git-process/git_lib'
+require 'highline/import'
+
+
+module GitProc
+
+  #
+  # Provides support for prompting the user when the dir/index is dirty.
+  #
+  # = Assumes =
+  # log_level
+  # workdir
+  #
+  module ChangeFileHelper
+    include GitLib
+
+
+    def offer_to_help_uncommitted_changes
+      stat = status
+
+      if stat.unmerged.empty?
+        handle_unknown_files(stat)
+        handle_changed_files(status) # refresh status in case it changed earlier
+      else
+        logger.info { "Can not offer to auto-add unmerged files: #{stat.unmerged.inspect}" }
+        raise UncommittedChangesError.new
+      end
+    end
+
+
+    def handle_unknown_files(stat)
+      if not stat.unknown.empty?
+        resp = ask_how_to_handle_unknown_files(stat)
+        if resp == :add
+          add(stat.unknown)
+        end
+      end
+    end
+
+
+    def handle_changed_files(stat)
+      if not stat.modified.empty? or not stat.added.empty? or not stat.deleted.empty?
+        resp = ask_how_to_handle_changed_files(stat)
+        if resp == :commit
+          add((stat.added + stat.modified - stat.deleted).sort.uniq)
+          remove(stat.deleted)
+          commit(nil)
+        else
+          stash_save
+          @stash_pushed = true
+        end
+      end
+    end
+
+
+    def ask_how_to_handle_unknown_files(stat)
+      show_changes(:unknown, stat)
+      resp = ask("Would you like to (a)dd them or (i)gnore them? ") do |q|
+        q.responses[:not_valid] = "Please respond with either (a)dd or (i)gnore. (Ctl-C to abort.) "
+        q.case = :down
+        q.validate = /a|i/i
+      end
+
+      resp == 'a' ? :add : :ignore
+    end
+
+
+    def show_changes(type, stat)
+      files = stat.send(type)
+
+      if type != :deleted
+        files -= stat.deleted
+      end
+
+      if not files.empty?
+        say("You have <%= color('#{type}', [:underline]) %> files:\n  <%= color('#{files.join("\n  ")}', [:bold]) %>")
+      end
+    end
+
+
+    def ask_how_to_handle_changed_files(stat)
+      [:added, :modified, :deleted].each { |t| show_changes(t, stat) }
+      resp = ask("Would you like to (c)ommit them or (s)tash them? ") do |q|
+        q.responses[:not_valid] = "Please respond with either (c)ommit or (s)tash. (Ctl-C to abort.) "
+        q.case = :down
+        q.validate = /c|s/i
+      end
+
+      resp == 'c' ? :commit : :stash
+    end
+
+  end
+
+end

data/lib/git-process/git_branch.rb

@@ -70,7 +70,7 @@ module GitProc
     end
 
 
-    def delete(force = false)
+    def delete!(force = false)
       if local?
         @lib.branch(@name, :force => force, :delete => true)
       else

data/lib/git-process/git_branches.rb

@@ -61,7 +61,7 @@ module GitProc
     def [](branch_name)
       branch_name = current.name if branch_name == 'HEAD'
       br = @items.find {|b| b.name == branch_name}
-      if br.nil? and branch_name !~ /origin\//
+      if br.nil? and branch_name !~ /origin\// and branch_name != '_parking_'
         @lib.logger.warn {"Could not find '#{branch_name}' in #{@items.map{|i|i.name}.join(',')}"}
       end
       br

data/lib/git-process/git_lib.rb

@@ -28,9 +28,16 @@ class String
 end
 
 
+class NilClass
+  def to_boolean
+    false
+  end
+end
+
+
 module GitProc
 
-  class GitExecuteError < StandardError
+  class GitExecuteError < GitProcessError
   end
 
 
@@ -44,7 +51,7 @@ module GitProc
   module GitLib
 
     def logger
-      unless @logger
+      if @logger.nil?
         @logger = Logger.new(STDOUT)
         @logger.level = log_level || Logger::WARN
         @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
@@ -77,26 +84,31 @@ module GitProc
 
 
     def add(file)
+      logger.info { "Adding #{[*file].join(', ')}" }
       command(:add, ['--', file])
     end
 
 
-    def commit(msg)
-      command(:commit, ['-m', msg])
+    def commit(msg = nil)
+      logger.info "Committing changes"
+      command(:commit, msg.nil? ? nil : ['-m', msg])
     end
 
 
     def rebase(base)
+      logger.info { "Rebasing #{branches.current.name} against #{base}" }
       command('rebase', base)
     end
 
 
     def merge(base)
+      logger.info { "Merging #{branches.current.name} with #{base}" }
       command(:merge, [base])
     end
 
 
     def fetch(name = remote_name)
+      logger.info "Fetching the latest changes from the server"
       command(:fetch, ['-p', name])
     end
 
@@ -211,6 +223,21 @@ module GitProc
     end
 
 
+    def stash_save
+      command(:stash, ['save'])
+    end
+
+
+    def stash_pop
+      command(:stash, ['pop'])
+    end
+
+
+    def show(refspec)
+      command(:show, refspec)
+    end
+
+
     def checkout(branch_name, opts = {}, &block)
       args = []
       args << '--no-track' if opts[:no_track]
@@ -237,10 +264,10 @@ module GitProc
     end
 
 
-    def remove(file, opts = {})
+    def remove(files, opts = {})
       args = []
       args << '-f' if opts[:force]
-      args << file
+      args << [*files]
       command(:rm, args)
     end
 
@@ -250,6 +277,9 @@ module GitProc
     end
 
 
+    private :config_hash
+
+
     def config(key = nil, value = nil, global = false)
       if key and value
         args = global ? ['--global'] : []

data/lib/git-process/git_process.rb

@@ -13,6 +13,7 @@
 require 'git-process/git_lib'
 require 'git-process/git_rebase_error'
 require 'git-process/git_merge_error'
+require 'highline/import'
 
 
 module GitProc
@@ -23,25 +24,20 @@ module GitProc
     def initialize(dir, opts = {})
       @log_level = Process.log_level(opts)
 
-      if dir
-        @workdir = find_workdir(dir)
-        if @workdir.nil?
-          @workdir = dir
-          logger.info { "Initializing new repository at #{workdir}" }
-          command(:init)
-        else
-          logger.debug { "Opening existing repository at #{workdir}" }
-        end
-      end
+      set_workdir(dir)
     end
 
 
     def run
       begin
+        verify_preconditions
+
         runner
       rescue GitProc::GitProcessError => exp
         puts exp.message
         exit(-1)
+      ensure
+        cleanup
       end
     end
 
@@ -51,6 +47,22 @@ module GitProc
     end
 
 
+    def set_workdir(dir)
+      if !dir.nil?
+        @workdir = find_workdir(dir)
+        if @workdir.nil?
+          @workdir = dir
+          logger.info { "Initializing new repository at #{workdir}" }
+          command(:init)
+        else
+          logger.debug { "Opening existing repository at #{workdir}" }
+        end
+      else
+        logger.debug "Process dir is nil"
+      end
+    end
+
+
     def workdir
       @workdir
     end
@@ -76,8 +88,39 @@ module GitProc
     end
 
 
+    def verify_preconditions
+      if should_remove_master
+        if ask_about_removing_master
+          branches[master_branch].delete!
+        end
+      end
+    end
+
+
+    def cleanup
+      # extension point
+    end
+
+
+    def should_remove_master
+      my_branches = branches()
+      has_a_remote? and
+      my_branches.include?(master_branch) and
+      my_branches.current.name != master_branch and
+      !keep_local_integration_branch? and
+      my_branches[integration_branch].contains_all_of(master_branch)
+    end
+
+
+    def keep_local_integration_branch?
+      keep_local_integration_branch_config_value.to_boolean
+    end
+
+
     def Process.log_level(opts)
-      if opts[:quiet]
+      if opts[:log_level]
+        opts[:log_level]
+      elsif opts[:quiet]
         Logger::ERROR
       elsif opts[:verbose]
         Logger::DEBUG
@@ -96,6 +139,28 @@ module GitProc
     private
 
 
+    def keep_local_integration_branch_config_value
+      config('gitProcess.keepLocalIntegrationBranch')
+    end
+
+
+    def ask_about_removing_master
+      resp = ask("You should remove your obsolete <%= color('local', [:bold]) %> branch, '#{master_branch}'. Should I remove it for you? (Yn) ") do |q|
+        q.responses[:not_valid] = 'Please respond with either (y)es or (n)o. Defaults to (y)es.'
+        q.case = :down
+        q.default = 'Y'
+        q.validate = /y|n/i
+      end
+
+      if resp == 'n'
+        say("(You can turn off this message using \"git config gitProcess.keepLocalIntegrationBranch true\").")
+        false
+      else
+        true
+      end
+    end
+
+
     def find_workdir(dir)
       if dir == File::SEPARATOR
         nil

data/lib/git-process/git_status.rb

@@ -41,26 +41,41 @@ module GitProc
         stat = s[0..1]
         file = s[3..-1]
         #puts "stat #{stat} - #{file}"
+        f = unquote(file)
         case stat
         when 'U ', ' U'
-          unmerged << file
+          unmerged << f
         when 'UU'
-          unmerged << file
-          modified << file
-        when 'M ', ' M'
-          modified << file
+          unmerged << f
+          modified << f
+        when 'M ', ' M', 'MM'
+          modified << f
+        when 'MD'
+          modified << f
+          deleted << f
         when 'D ', ' D'
-          deleted << file
+          deleted << f
         when 'DU', 'UD'
-          deleted << file
-          unmerged << file
+          deleted << f
+          unmerged << f
         when 'A ', ' A'
-          added << file
+          added << f
+        when 'AD'
+          added << f
+          deleted << f
         when 'AA'
-          added << file
-          unmerged << file
+          added << f
+          unmerged << f
         when '??'
-          unknown << file
+          unknown << f
+        when 'R '
+          old_file, new_file = file.split(' -> ')
+          deleted << unquote(old_file)
+          added << unquote(new_file)
+        when 'C '
+          old_file, new_file = file.split(' -> ')
+          added << unquote(old_file)
+          added << unquote(new_file)
         else
           raise "Do not know what to do with status #{stat} - #{file}"
         end
@@ -74,6 +89,11 @@ module GitProc
     end
 
 
+    def unquote(file)
+      file.match(/^"?(.*?)"?$/)[1]
+    end
+
+
     # @return [Boolean] are there any changes in the index or working directory?
     def clean?
       @unmerged.empty? and @modified.empty? and @deleted.empty? and @added.empty? and @unknown.empty?

data/lib/git-process/new_fb.rb

@@ -28,7 +28,7 @@ module GitProc
 
       if on_parking
         new_branch = checkout(@branch_name, :new_branch => '_parking_')
-        mybranches.parking.delete
+        mybranches.parking.delete!
         new_branch
       else
         checkout(@branch_name, :new_branch => integration_branch)

data/lib/git-process/rebase_to_master.rb

@@ -14,6 +14,7 @@ require 'git-process/git_process'
 require 'git-process/git_rebase_error'
 require 'git-process/git_process_error'
 require 'git-process/parked_changes_error'
+require 'git-process/uncommitted_changes_error'
 require 'git-process/github_pull_request'
 
 
@@ -21,18 +22,23 @@ module GitProc
 
   class RebaseToMaster < Process
 
-    def runner
+    def verify_preconditions
+      super
+
       raise UncommittedChangesError.new unless status.clean?
       raise ParkedChangesError.new(self) if is_parked?
+    end
 
+
+    def runner
       if has_a_remote?
         fetch(server_name)
-        proc_rebase(remote_master_branch)
+        proc_rebase(integration_branch)
         push(server_name, branches.current, master_branch)
         close_pull_request
         remove_feature_branch
       else
-        proc_rebase(master_branch)
+        proc_rebase(integration_branch)
       end
     end
 
@@ -42,6 +48,7 @@ module GitProc
 
       remote_master = mybranches[remote_master_branch]
       current_branch = mybranches.current
+      logger.debug { "Removing feature branch (#{current_branch})" }
 
       unless remote_master.contains_all_of(current_branch.name)
         raise GitProcessError.new("Branch '#{current_branch.name}' has not been merged into '#{remote_master_branch}'")
@@ -56,12 +63,12 @@ module GitProc
 
           logger.warn {bad_parking_branch_msg}
         else
-          parking_branch.delete
+          parking_branch.delete!
         end
       end
       remote_master.checkout_to_new('_parking_', :no_track => true)
 
-      current_branch.delete(true)
+      current_branch.delete!(true)
       if mybranches["#{server_name}/#{current_branch.name}"]
         push(server_name, nil, nil, :delete => current_branch.name)
       end