cap_git_tools 0.8.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cap_git_tools.gemspec
+gemspec

data/README.md

@@ -0,0 +1,170 @@
+# cap_git_tools
+
+Re-usable, composable [Capistrano](https://github.com/capistrano/capistrano) tasks for git tagging and other work with the
+git repository you use for your Cap deploys. 
+
+* Ensure your local git is committed and pushed, so you are deploying what you
+think you are. 
+* Automatically git tag the deploy
+* Enforce a [multistage](https://github.com/capistrano/capistrano/wiki/2.x-Multistage-Extension) workflow where only a tagged staging release can be deployed
+to production (ala [gitflow](https://github.com/apinstein/git-deployment))
+
+Functionality is split into discrete yet composable tasks, with sensible defaults 
+but configurable, so you can build a cap recipe that fits *your*
+requirements and workflow. Ordinary single stage or multi-stage; with or without
+interactive confirmation prompts; using git however you're already or would like
+to be using it. 
+
+(_Inspired by Alan Pinstein and Josh Nichols' neat
+[gitflow](https://github.com/apinstein/git-deployment), but refactored for more
+flexiblity with less hardcoded workflow. Some functionality changed in the
+process.)_
+
+## Installation
+
+    gem install cap_git_tools
+    
+Or if in the context of something using bundler such as Rails, add to Gemfile
+eg:
+
+    gem 'cap_git_tools', :group => :development
+    
+Add to top of a relevant Capistrano file (such as config/deploy.rb ordinarily):
+
+    require 'cap_git_tools/tasks'
+    
+This makes cap_git_tool's tasks available to you, but doesn't automatically wire
+them up to be used by your `cap deploy`. See below.
+
+You probably want to make sure you have an `ssh-agent` set up, or you'll have to
+enter your private key password to access git several times. You will need to be
+running your cap recipes from a directory with a git checkout (usual behavior
+for cap usage, but not actually required otherwise by cap). 
+
+## Ensure git is committed and pushed when deploying
+
+Have you ever deployed the 'wrong' thing, because you forgot to commit and/or
+push your changes to git?  I have. 
+
+Have cap make sure you're committed and pushed before deploying by adding to
+your recipe in deploy.rb: 
+
+    before "deploy:update_code", "git:guard_committed", "git:guard_upstream"
+    
+Or use just one or the other
+
+* `guard_committed` makes sure you have no uncommitted changes. _IF_ you have a :branch set
+   in your cap recipe, it will also make sure your curent checkout matches that branch. 
+* `guard_upstream` makes sure the current working copy branch committed tip (or local branch matching Cap
+  :branch, if set) matches the upstream remote version. 
+ 
+## Automatically tag on deploy
+
+Every time you deploy, want to have Capistrano automatically tag exactly what
+gets deployed, with a tag like "deploy-2012-04-11-1517"?  
+
+Add this to your Cap recipe, usefully combining with the tasks to make sure
+your git copy is 'clean' as discussed above:
+
+    before "deploy:update_code", "git:guard_committed", "git:guard_pushed", "git:tag"
+   
+That's a date and timestamp, deploy-yyyy-mm-dd-hhmm.
+
+If you are using multistage, instead of "deploy-" as a prefix, it'll use 
+the current stage name like "production" or "staging" (but see below for
+fancier multi-stage workflow). 
+
+Ordinarily what's in your current git checkout will be tagged; but if
+you have set cap's `:branch`, it'll tag and deploy the HEAD of that branch
+even if that's not your current checkout. 
+
+You can customize the prefix and other aspects of tagging, both in your recipe 
+and with command line over-rides, see `cap -E git:tag` for more info. 
+
+## Multistage workflow
+
+Are you using Capistrano's [multistage
+extension](https://github.com/capistrano/capistrano/wiki/2.x-Multistage-Extension)? 
+In one commonly desired multistage workflow (similar to what
+[gitflow](https://github.com/apinstein/git-deployment) enforces):
+ 
+ * Under staging, you want automatic tagging with staging-yyyy-mm-dd-hhmm, just 
+   as above under 'Automatically tag on deploy'. Add to your `config/staging.rb`:
+   
+           before "deploy:update_code", "git:guard_committed", "git:guard_upstream", "git:tag"
+      
+ * Under production, you want to take the most recent 'staging' tag, and promote
+   it by deploying that tag to production, re-tagging with a "production-" tag.
+   Maybe you also want to print out the commit log between the last production
+   tag and what you're about to deploy, and require interactive confirmation.
+   Add to your `config/deploy.rb`:
+   
+           before "deploy:update_code",  "git:commit_log", "git:retag"
+           set :confirm_tag, true
+       
+Say you `cap staging deploy` on April 1 2012 at noon, your deploy will be
+tagged `staging-2012-04-01-1200`. 
+
+Say on April 2 at noon, you run `cap production deploy`
+
+* you'll be a shown a commit log of changes between the previous `production-` 
+commit and your most recent `staging-` commit, `staging-2012-04-01-1200`.
+(`git:commit_log`) 
+* You'll be asked to confirm, (`set :confirm_tag, true`) 
+* And then the deploy will happen, with new tag added `production-2012-04-02-1200` 
+  (`git:retag`). 
+  * Note it's timestamped with date of production deploy.  The commit message
+  for the `production-` tag will say which `staging-` tag was retagged. 
+     
+The `git:retag` task has some configurable options (in your recipe or on the
+individual command line invocation) too, see `cap -e git:retag`. 
+ 
+## Make your own recipe
+
+Look at `cap -T git` to see the tasks added by cap_git_tools. Run `cap -e
+taskname` to see expanded documentation info on each one, covering more 
+specifics of what it does and what cap variables can alter it's behavior. 
+
+Some behaviors can be customized by 'capistrano variables'. These can be set in
+a recipe:
+
+    set :variable, "value"
+   
+Or set/over-ridden on the individual cap command line invocation:
+
+    cap deploy -s variable=value
+   
+Doesn't matter if you use cap '-s' or '-S', cap_git_tools tasks always lazily
+look up these values. 
+
+## Other tools
+
+`cap git:commit_log` to see the commits between the *last* tagged release
+and what you'd deploy now with `cap deploy`. Works in singlestage recipe, or
+multistage under 'cap staging git:commit_log' or 'cap production
+git:commit_log'. 
+
+`cap git:show_tags` to show the last 3 deploy tags, with meta information.
+Works in single stage recipe or multistage. 
+
+## To Be Done
+
+* Tag names are automatically created with a year-month-day-hour-minute timestamp.
+However, if you try to deploy again before the minute's changed on the clock,
+the tasks will try to re-tag using an already used name. You'll get an error and
+the task will abort, but the task could be written to catch this and add a
+suffix. But it ain't yet. 
+
+* There is some limited experimental functionality to change the format and add
+new components to the automatically created tag name, using a
+[:tag_template](https://github.com/jrochkind/cap_git_tools/blob/master/lib/cap_git_tools/task_helpers.rb#L162)
+variable. This theoretically allows the `who` and `what` components used by
+gitflow.  But doing the 'right thing' in multistage (copying the 'what' from the
+previous tag, but regenerating the rest) is a bit tricky, and hasn't been done
+yet, which is what keeps this functionality limited and experimental at this
+point. 
+
+## Let me know
+
+Feedback, pull requests, complaints, welcome. Not sure if anyone's gonna use
+this. 

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/cap_git_tools.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cap_git_tools/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cap_git_tools"
+  s.version     = CapGitTools::VERSION
+  s.authors     = ["Jonathan Rochkind"]
+  s.email       = ["jonathan@dnil.net"]
+  s.homepage    = ""
+  s.summary     = %q{re-usable, composable Capistrano tasks for git tagging and other work with a git repo}
+
+  s.rubyforge_project = "cap_git_tools"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_dependency "capistrano", "~> 2.0"
+end

data/lib/cap_git_tools.rb

@@ -0,0 +1,5 @@
+require "cap_git_tools/version"
+
+module CapGitTools
+  # We don't really do anything by default on gem load. 
+end

data/lib/cap_git_tools/task_helpers.rb

@@ -0,0 +1,194 @@
+# methods used by tasks defined in tasks.rb
+#
+# generally this module is 'include'd into a cap
+# :namespace, seems to do what we want. 
+require 'cap_git_tools'
+
+module CapGitTools::TaskHelpers
+   ####
+    # Some functions used by the tasks
+    #
+    
+    # say with an indent in spaces
+    def say_formatted(msg, options = {})
+      options.merge!(:indent => 4)
+      Capistrano::CLI.ui.say(' ' * options[:indent] + msg )
+    end
+    
+    # execute a 'git fetch', but mark in a private variable that
+    # we have, so we only do it once per cap execution. 
+    def ensure_git_fetch
+      unless @__git_fetched      
+        local_sh "git fetch #{upstream_remote}"
+        @__git_fetched = true
+      end
+    end
+    
+    # execute locally as a shell command, echo'ing to output, as
+    # well as capturing error and aborting. 
+    def local_sh(cmd)
+      say_formatted("executing locally: #{cmd}")
+      `#{cmd}`
+      abort("failed: #{cmd}") unless $? == 0
+    end
+    
+    # How to refer to the upstream git repo configured in cap :repository?
+    # Will _usually_ return 'origin', will sometimes return another remote,
+    # will occasionally return a raw git url when it's not configured in
+    # remotes for some reason. 
+    #
+    # This used to be hard-coded to 'origin'. Then it was configurable.
+    # Then I realized it _has_ to be whatever is set in cap :repository.
+    # We'll look up the remote alias for that, if available, and cache
+    # the lookup. Usually it'll be 'origin',  yeah. 
+    def upstream_remote
+      @__upstream_remote = begin
+        git_url = fetch(:repository)        
+        
+        remote_info = 
+        `git remote -v`.
+          split("\n").
+          collect {|line| line.split(/[\t ]/) }.
+          find {|list| list[1] == git_url }
+        
+        remote_info ? remote_info[0] : git_url
+      end
+    end
+    
+  
+    # what branch we're going to tag and deploy -- if cap 'branch' is set,
+    # use that one, otherwise use current branch in checkout
+    def working_branch
+      @__git_working_branch ||= begin
+        if exists?("branch")
+          fetch(:branch)
+        else
+          b = `git symbolic-ref -q HEAD`.sub(%r{^refs/heads/}, '').chomp
+          b.empty? ? "HEAD" : b
+        end
+      end
+      
+    end
+    
+    # current SHA fingerprint of local branch mentioned in :branch
+    def local_sha
+      `git log --pretty=format:%H #{working_branch} -1`.chomp
+    end
+    
+    def tag_prefix
+      fetch(:tag_prefix, fetch(:stage, "deploy"))
+    end
+    
+    def from_prefix
+      fetch("from_prefix", "staging")
+    end
+  
+    
+    # mostly used by git:retag, calculate the tag we'll be retagging FROM. 
+    #
+    # can set cap :from_tag. Or else find last tag matching from_prefix,
+    # which by default is "staging-*"
+    def from_tag
+      t = nil
+      if exists?("from_tag")
+        t = fetch("from_tag")
+      else
+        t = fetch_last_tag(  self.from_prefix ) 
+      
+        if t.nil? || t.empty?
+          abort("failed: can't find existing tag matching #{self.from_prefix}-*")
+        end
+      end
+      return t
+    end
+    
+    # find the last (chronological) tag with given prefix. 
+    # prefix can include shell-style wildcards like '*'. Defaults to
+    # last tag with current default tag_prefix. 
+    #
+    # Note: Will only work on git 'full' annotated tags (those signed or 
+    # with -m message or -a) because git only stores dates for annotated tags.
+    # others will end up sorted lexicographically BEFORE any annotated tags. 
+    def fetch_last_tag(pattern_prefix = self.tag_prefix)
+      # make sure we've fetched to get latest from upstream. 
+      ensure_git_fetch
+      
+      # crazy git command, yeah. Sort by tagged date descending, one line only, 
+      # output refname:short, look for tags matching our pattern.  
+      last_tag = `git for-each-ref --count=1 --sort='-taggerdate' --format='%(refname:short)' 'refs/tags/#{pattern_prefix}-*' 2>/dev/null`.chomp
+      return nil if last_tag == ''
+      return last_tag
+    end
+    
+    # show commit lot from commit-ish to commit-ish,
+    # using appropriate UI tool. 
+    #
+    # If you have cap :github_browser_compare set and the remote is github,
+    # use `open` to open in browser. 
+    #
+    # else if you have ENV['git_log_command'] set, pass to `git` (don't know
+    # what this is for, inherited from gitflow)
+    #
+    # else just use an ordinary command line git log   
+    def show_commit_log(from_tag, to_tag)
+      if fetch("github_browser_compare", false ) && `git config remote.#{upstream_remote}.url` =~ /git@github.com:(.*)\/(.*).git/      
+        # be awesome for github, use `open` in browser
+        command = "open https://github.com/#{$1}/#{$2}/compare/#{from_tag}...#{to_tag}"
+      elsif ENV['git_log_command'] && ENV['git_log_command'].strip != ''
+        # use custom compare command if set
+        command = "git #{ENV['git_log_command']} #{from_tag}..#{to_tag}"
+      else
+        # standard git log command
+        command = "git log #{from_tag}..#{to_tag}"      
+      end
+      
+      say_formatted "Displaying commits from #{from_tag} to #{to_tag}\n\n"
+      say_formatted command + "\n\n"
+      system command
+      puts "" # newline
+    end
+      
+    
+    def calculate_new_tag
+      # if capistrano :tag is already set, just use it        
+      if exists?("tag")
+        return fetch("tag")
+      end
+      
+      # otherwise calculate, based on template
+            
+      tag_suffix = fetch("tag_template", "%{datetime}")
+        
+      tag_suffix.gsub!(/\%\{([^}]+)\}/) do 
+        case $1
+        when 'date'
+          Time.now.localtime.strftime('%Y-%m-%d')
+        when 'datetime'
+          Time.now.localtime.strftime('%Y-%m-%d-%H%M')
+        when 'what'
+          (@__git_what = Capistrano::CLI.ui.ask("What does this release introduce? (this will be normalized and used in the tag for this release) ").gsub(/[ '"]+/, "_"))
+        when 'who'
+          `whoami`.chomp
+        end
+      end
+        
+      return "#{tag_prefix}-#{tag_suffix}"    
+    end
+    
+    # will prompt to confirm new tag, if :confirm_tag is true, otherwise
+    # no-op. 
+    def guard_confirm_tag(new_tag)    
+      if exists?("confirm_tag") && [true, "true"].include?( confirm_tag )      
+        prompt = "Do you really want to deploy "
+        prompt += new_tag
+        prompt += " to #{stage}" if exists? :stage
+        prompt += "?"
+                
+        unless Capistrano::CLI.ui.agree(prompt) 
+          abort("exiting, user cancelled.")
+        end
+      end
+    end
+    
+  
+end

data/lib/cap_git_tools/tasks.rb

@@ -0,0 +1,301 @@
+# Written using crazy meta-code cribbed from capistrano_ext so you
+# can (and must) 'require' this file rather than 'load' it.
+require 'capistrano'
+
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "cap_git_tools requires Capistrano 2"
+end
+
+require 'cap_git_tools/task_helpers'
+
+
+
+Capistrano::Configuration.instance.load do  
+
+    
+  namespace :git do
+    # include our helper methods, I believe just into this namespace
+    # if we do it this way. 
+    extend CapGitTools::TaskHelpers
+    
+    desc <<-DESC
+      Ensure git working copy has no uncommitted changes, or abort. 
+         
+      If cap :branch is set, will also ensure git working copy is on same
+      branch as :cap branch. 
+     
+      The idea is to make sure you're deploying what you're looking at.      
+      See also git:guard_upstream, you often want to use both to ensure
+      this. 
+      
+        before "git:tag", "git:check_committed", "git:check_upstream"
+      or
+        before "deploy",  , "git:check_committed", "git:check_upstream"
+     
+      setting cap :skip_guard_committed to true will skip even if task is 
+      invoked. (eg, `cap deploy -s skip_guard_upstream=true`) 
+    DESC
+    task :guard_committed do
+      if [true, "true"].include? fetch("skip_guard_committed", false)
+        say_formatted("Skipping git:guard_committed")
+      else  
+        if exists?("branch")
+          working_branch = `git symbolic-ref -q HEAD`.sub(%r{^refs/heads/}, '').chomp
+          unless fetch("branch") == working_branch
+            abort %Q{failed: guard_committed: wrong branch
+    
+        You have configured to deploy from branch #{fetch("branch")}
+        but your git working copy is on branch #{working_branch}
+    
+            git checkout #{fetch("branch")}
+    
+        and try again. Or, to skip this check, execute cap again with:
+            
+            -s skip_guard_committed=true    
+            }
+          end
+        end
+        
+        # cribbed from bundle release rake task
+        `git diff HEAD --exit-code` 
+        return_code = $?.to_i
+        if return_code == 0
+          say_formatted("guard_clean: passed")
+        else
+          abort %Q{failed: guard_committed: uncomitted changes
+    
+    There are files that need to be committed first.
+        
+    Or, to skip this check, execute cap again with:        
+       -s skip_guard_committed=true  
+          }
+        end
+      end
+    end
+  
+    desc <<-DESC
+      Ensure sure local git has been pushed to upstream, or abort
+     
+      * 'upstream' is whatever you have configured as cap :repository
+      * Looks in :branch (default 'master') to see what branch should be checked,
+        Assumes local :branch tracks upstream_remote/branch
+        
+      The idea is to ensure what you're deploying is what you're looking at.
+      See also git:guard_committed, you usually want to use both to ensure this. 
+      
+        before "git:tag", "git:check_committed", "git:check_upstream"
+      or if not using git:tag, eg
+        before "deploy",  , "git:check_committed", "git:check_upstream"
+
+      setting cap :skip_guard_upstream to truewill skip even if task is invoked.
+      (eg, `cap deploy -s skip_guard_upstream=true`) 
+    DESC
+    task :guard_upstream do   
+      if [true, "true"].include? fetch("skip_guard_upstream", false)
+        say_formatted("Skipping git:guard_upstream")
+      else      
+  
+        ensure_git_fetch
+        
+        remote_sha = `git log --pretty=format:%H #{upstream_remote}/#{working_branch} -1`.chomp
+        
+        unless local_sha == remote_sha
+          abort %Q{failed:
+    Your local #{working_branch} branch is not up to date with #{upstream_remote}/#{working_branch}.
+    This will likely result in deploying something other than you expect.
+    
+    Please make sure you have pulled and pushed all code before deploying:
+    
+        git pull #{upstream_remote} #{working_branch}
+        # run tests, etc
+        git push #{upstream_remote} #{working_branch}
+    
+    Or, to skip this check run cap again with `-s skip_guard_upstream=true`
+          }
+        end
+        
+        say_formatted("guard_upstream: passed")
+      end
+    end
+    
+    desc <<-DESC
+      Tags the current checkout and pushes tag to remote.
+      
+      Normally will tag and deploy whatever is in your current git working
+      copy -- you may want to use with the guard tasks to make sure
+      you're deploying what you think and sync'ing it to your upstream
+      repository:
+      
+        before "deploy", "git:guard_committed", "git:guard_upstream", "git:tag"
+        
+      However, if you have set cap :branch, git:retag will tag the HEAD
+      of THAT branch, rather than whatever is the current working copy
+      branch. 
+      
+      Either way, git:tag:
+      * pushes the new tag to upstream remote git
+      * sets the cap :branch variable to the newly created tag, to be 
+        sure cap deploys that tag. 
+      
+      What will the created tag look like?
+      
+      Without multi-stage, by default something like `deploy-yyyy-mm-dd-hhmm`. 
+      
+      * The deploy- prefix will be the current stage name if multi-stage.
+      * The prefix can be manually set in config file or command line
+        with cap :tag_prefix variable instead.
+      * Somewhat experimental, you can also set :tag_template to change the
+        part after the prefix.
+      * or you can specify a complete tag on the cap command line `-s tag=deploy-whatever`.  
+      
+      `set :confirm_tag, true` in the config file to force an interactive
+      prompt and confirmation before continuing. 
+    DESC
+    task :tag do    
+      
+      # make sure we have any other deployment tags that have been pushed by
+      # others so our auto-increment code doesn't create conflicting tags
+      ensure_git_fetch
+  
+      tag = calculate_new_tag
+      
+      commit_msg = @__git_what || "cap git:tag: #{tag}"
+      
+      self.guard_confirm_tag(tag)
+      
+      # tag 'working_branch', means :branch if set, otherwise
+      # current working directory checkout. 
+      local_sh "git tag -a -m '#{commit_msg}' #{tag} #{self.working_branch}"
+  
+      # Push new tag back to origin
+      local_sh "git push -q #{upstream_remote} #{tag}"
+      
+      # set :branch to tag, so cap will continue on to deploy the tag we just created!    
+      set(:branch, tag)
+    end
+    
+    desc <<-DESC
+      Takes an already existing tag, and retags it and deploys that tag.
+    
+        Will push the new tag to upstream repo, and set the new tag as cap 
+        :branch so cap willd deploy it.  
+    
+        Usually used in git multistage for moving from staging to production, 
+        for instance in your production.rb:
+        
+          before "deploy", "git:retag" 
+        
+        Or use with the guard tasks:
+          before "deploy", "git:guard_committed", "git:guard_upstream", "git:retag"
+        
+        `set :confirm_tag, true` in the config file to force an interactive
+        prompt and confirmation before continuing. 
+        
+        What tag will be used as source tag?
+        
+        * Normally the most recent tag beginning "staging-"
+        * Or set cap :tag_prefix in config file or command line
+          to use a different prefix.
+        * Or set :tag_from in config file or on command line
+          to specify a specific tag. `cap deploy -s tag_from=staging_something`
+          
+        What will the newly created tag look like? Same rules as for
+        git:tag. 
+        
+        * By default in a production stage it's going to look 
+        like `production-yyyy-mm-dd-hhmm`, but there are several
+        of cap variables you can set in a config file to change this,
+        including :tag_prefix and :tag_template         
+    DESC
+    task :retag do
+      from_tag = self.from_tag
+      
+      to_tag = calculate_new_tag
+      
+      self.guard_confirm_tag(from_tag)
+      
+      say_formatted("git:retag taking #{from_tag} and retagging as #{to_tag}")
+      
+      local_sh "git tag -a -m 'tagging #{from_tag} for deployment as #{to_tag}' #{to_tag} #{from_tag}"
+      
+      # Push new tag back to origin
+      local_sh "git push -q #{upstream_remote} #{to_tag}"
+        
+      set(:branch, to_tag)
+    end
+    
+    desc <<-DESC
+      Show 5 most recent tags set by git:tag or git:retag
+      
+      Can be used to see what you've deployed recently. 
+      
+         cap git:show_tags
+       or for multi-stage:
+         cap staging git:show_tags
+         cap production git:show_tags
+      
+      Looks for tags matching the prefix that the tag or retag task
+      would use to tag. Ie, 'deploy-', or 'stagename-' in multi-stage,
+      or according to :tag_prefix setting. 
+     
+      Will also output date of tag, commit message, and account doing the commit.            
+    DESC
+    task :show_tags do               
+      # in newer versions of git you could prob do this with a git-log instead with
+      # certain arguments, but my local git is too old to support --tags arg properly.
+      system "git for-each-ref --count=4 --sort='-taggerdate' --format='\n* %(refname:short)\n    Tagger: %(taggeremail)\n    Date: %(taggerdate)\n\n    %(subject)' 'refs/tags/#{tag_prefix}-*' "
+    end
+    
+  
+    desc <<-DESC
+     Show log between most tagged deploy and what would be deployed now.                
+     
+     Requires you to be using git:tag or git:retag to make any sense,
+     so we can find the 'last deployed' tag to compare. 
+     
+     You can run this manually:
+         cap git:commit_log
+     Or for multi-stage, perhaps:
+         cap staging git:commit_log
+         cap production git:commit_log
+     Or you can use cap callbacks to ensure this is shown before
+     a deploy, for multi-stage for instance add to your production.rb:
+        before "git:retag", "git:commit_log"
+        # and force an interactive confirmation after they've seen it
+        set :confirm_retag, true     
+     
+     Ordinarily shows commit log between current git working copy
+     (forced to current head of :branch if cap :branch is set), and
+     last deployed tag, by default tag beginning "deploy-", or
+     tag beginning :stage if you are cap multi-stage, or beginning
+     with :tag_prefix if that is set. 
+          
+     Hard-coded to do something special if you are using multistage
+     cap, and are in stage 'production' -- in that case it will
+     show you the commits between the most recent production-* tag,
+     and the most recent staging-* tag. (Cap :tag_prefix and :from_prefix
+     can change those tag prefixes).      
+    DESC
+    task :commit_log do
+      from, to = nil, nil
+      
+      if exists?("stage") && stage.to_s == "production"
+        # production stage in multi-stage
+        from =  fetch_last_tag # last deploy-* tag, or last :tag_prefix tag
+        to = from_tag # last staging-* tag, or last :from_prefix tag
+      else
+        # 'staging' stage in multi-stage, or else any old
+        # non-multistage. 
+        from = fetch_last_tag # last deploy-* tag, or last :tag_prefix tag
+        to = local_sha.slice(0,8) # current git working copy, or local branch head. 
+      end
+      
+      show_commit_log(from, to)
+    end
+    
+    
+    
+  end
+  
+  
+end

data/lib/cap_git_tools/version.rb

@@ -0,0 +1,3 @@
+module CapGitTools
+  VERSION = "0.8.0"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: cap_git_tools
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Rochkind
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email:
+- jonathan@dnil.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- cap_git_tools.gemspec
+- lib/cap_git_tools.rb
+- lib/cap_git_tools/task_helpers.rb
+- lib/cap_git_tools/tasks.rb
+- lib/cap_git_tools/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cap_git_tools
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: re-usable, composable Capistrano tasks for git tagging and other work with
+  a git repo
+test_files: []