auto_tagger 0.0.9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [Jeff Dean]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+# IMPORTANT NOTE
+
+This gem is still in it's infancy, and lots of things might change.  Since this creates and pushes tags to your git repository, please use with caution.
+
+# AutoTagger
+
+AutoTagger is a gem that helps you automatically create a date-stamped tag for each stage of your deployment, and deploy from the last tag from the previous environment.
+
+Let's say you have the following workflow:
+
+ * Run all test on a Continuous Integration (CI) server
+ * Deploy to a staging server
+ * Deploy to a production server
+
+You can use the `autotag` command to tag releases on your CI box, then use the capistrano tasks to auto-tag each release.
+
+## Installation
+
+    gem sources -a http://gems.github.com
+    sudo gem install zilkey-auto_tagger
+
+## Contribute
+
+  * [Tracker Project](http://www.pivotaltracker.com/projects/11988)
+  * [GitHub Repository](http://github.com/zilkey/auto_tagger/tree/master)
+
+## The autotag executable
+
+Installing the gem creates an executable file named autotag, which takes two arguments: the stage, and optionally the path to the git repo:
+
+    $ autotag demo  # => creates a tag like demo/200804041234 in the current directory
+    $ autotag demo . # => same as above
+    $ autotag demo /Users/me/foo # => cd's to /Users/me/foo before creating the tag
+
+Running autotag does the following:
+
+    $ git fetch origin --tags
+    $ git tag <stage>/<timestamp>
+    $ git push origin --tags
+
+## Capistrano Integration
+
+AutoTagger comes with 2 capistrano tasks: 
+
+  * `release_tagger:set_branch` tries to set the branch to the last tag from the previous environment.
+  * `release_tagger:create_tag` runs autotag for the current stage
+
+Example `config/deploy.rb` file:
+
+    require 'release_tagger'
+
+    # The :autotagger_stages variable is required
+    set :autotagger_stages, [:ci, :staging, :production]
+
+    # The :working_directory variable is optional, and defaults to Dir.pwd
+    # :working_directory can be an absolute or relative path
+    set :working_directory, "../../"
+
+    task :production do
+      # In each of your environments that need auto-branch setting, you need to set :stage
+      set :stage, :production
+    end
+
+    task :staging do
+      # If you do not set stage, it will not auto-set your branch
+      # set :stage, :staging
+    end
+
+    # You need to add the before/ater callbacks yourself
+    before "deploy:update_code", "release_tagger:set_branch"
+    after  "deploy", "release_tagger:create_tag"
+    after  "deploy", "release_tagger:write_tag_to_shared"
+    after  "deploy", "release_tagger:print_latest_tags"
+
+### Cpistano-ext multistage support
+
+If you use capistano-ext multistage, you can use auto_tagger.
+
+    set :autotagger_stages, [:ci, :staging, :production]
+    set :stages, [:staging, :production]
+    set :default_stage, :staging
+    require 'capistrano/ext/multistage'
+
+When you deploy, autotagger will auto-detect your current stage.
+
+### release_tagger:set_branch
+
+This task sets the git branch to the latest tag from the previous stage.  Assume you have the following tags in your git repository:
+
+  * ci/01
+  * staging/01
+  * production/01
+
+And the following stages in your capistrano file:
+
+    set :autotagger_stages, [:ci, :staging, :production]
+
+The deployments would look like this:
+
+    cap staging release_tagger:set_branch    # => sets branch to ci/01
+    cap production release_tagger:set_branch # => sets branch to staging/01
+
+You can override with with the -Shead and -Stag options
+
+    cap staging release_tagger:set_branch -Shead=true      # => sets branch to master
+    cap staging release_tagger:set_branch -Stag=staging/01 # => sets branch to staging/01
+
+If you add `before "deploy:update_code", "release_tagger:set_branch"`, you can just deploy with:
+
+    cap staging deploy
+    
+and the branch will be set for you automatically.
+
+### release_tagger:create_tag
+
+This cap task creates a new tag, based on the latest tag from the previous environment.  
+
+If there is no tag from the previous stage, it creates a new tag from the latest commit in your _working directory_.
+
+If you don't specify any `autotagger_stages`, autotagger will create a tag that starts with "production".
+
+### release_tagger:print_latest_tags
+
+This task reads the git version from the text file in shared:
+
+    cap staging release_tagger:read_tag_from_shared
+
+### release_tagger:print_latest_tags
+
+This task takes the latest tag from each environment and prints it to the screen.  You can add it to your deploy.rb like so:
+
+    after  "deploy", "release_tagger:print_latest_tags"
+
+Or call it directly, like:
+
+    cap production release_tagger:print_latest_tags
+    
+This will produce output like:
+
+    ** AUTO TAGGER: release tag history is:
+     ** ci         ci/20090331045345              8031807feb5f4f99dd83257cdc07081fa6080cba some commit message
+     ** staging    staging/20090331050908         8031807feb5f4f99dd83257cdc07081fa6080cba some commit message
+     ** production production/20090331050917      8031807feb5f4f99dd83257cdc07081fa6080cba some commit message
+
+## Running tests:
+
+You must be able to ssh into your box via localhost (remote login).  To make this easier, add your own key to your own account:
+
+    cat ~/.ssh/id_rsa.pub >>~/.ssh/authorized_keys
+    
+To ensure that this has worked, try this:
+
+    ssh localhost
+    
+If it asks you for a password, you've done something wrong.
+
+To run the specs, execute:
+
+    spec spec/
+    
+To run the cucumber features, execute:
+
+    cucumber features/
+
+## Acknowledgments
+
+Special thanks to 
+
+ * Brian Takita for the original recipes
+ * Mike Dalessio for his git fu
+ * Chad Wooley for his feature ideas
+ * Tim Holahan for his QA
+
+## Links
+
+ * http://codeintensity.blogspot.com/2008/06/changelogs-and-deployment-notification.html
+  
+Copyright (c) 2009 [Jeff Dean], released under the MIT license

data/bin/autotag

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "auto_tagger"))
+require 'getoptlong'
+
+opts = GetoptLong.new(
+  ['--help', '-h', '-?', GetoptLong::NO_ARGUMENT]
+)
+
+def usage
+  puts
+  puts "USAGE: #{File.basename($0)} <stage> [<repository>]"
+  puts
+  puts '    where:    stage       sets the tag prefix'
+  puts '              repository  sets the repository to act on - defualts to the current directory'
+  puts
+  puts '    examples: autotag'
+  puts '              autotag .'
+  puts '              autotag ../'
+  puts '              autotag /data/myrepo'
+  puts '              autotag demo'
+  puts
+  puts
+  exit 0
+end
+
+opts.each do |opt, arg|
+  case opt
+  when "--help"
+    usage
+  end
+end
+
+if ARGV[0]
+  AutoTagger.new(ARGV[0], ARGV[1]).create_tag
+  exit 0
+else
+  usage
+end

data/lib/auto_tagger/auto_tagger.rb

@@ -0,0 +1,26 @@
+class AutoTagger
+
+  class EnvironmentCannotBeBlankError < StandardError; end
+
+  attr_reader :stage, :repository, :working_directory
+
+  def initialize(stage, path = nil)
+    raise EnvironmentCannotBeBlankError if stage.to_s.strip == ""
+    @working_directory = File.expand_path(path ||= Dir.pwd)
+    @repository = Repository.new(@working_directory)
+    @stage = stage
+  end
+
+  def create_tag(commit = nil)
+    repository.tags.fetch
+    new_tag = repository.tags.create(stage, commit)
+    repository.tags.push
+    new_tag
+  end
+
+  def latest_tag
+    repository.tags.fetch
+    repository.tags.latest_from(stage)
+  end
+
+end

data/lib/auto_tagger/capistrano_helper.rb

@@ -0,0 +1,39 @@
+class CapistranoHelper
+
+  attr_reader :variables, :stage, :working_directory
+
+  def initialize(variables)
+    @stage_manager = StageManager.new(variables[:autotagger_stages])
+    @variables = variables
+    @stage = variables[:stage]
+    @working_directory = variables[:working_directory] || Dir.pwd
+  end
+
+  def previous_stage
+    @stage_manager.previous_stage(stage)
+  end
+
+  def branch
+    if variables.has_key?(:head)
+      variables[:branch]
+    elsif variables.has_key?(:tag)
+      variables[:tag]
+    elsif previous_stage && (latest = AutoTagger.new(previous_stage, working_directory).latest_tag)
+      latest
+    else
+      variables[:branch]
+    end
+  end
+
+  def release_tag_entries
+    entries = []
+    @stage_manager.stages.each do |stage|
+      tagger = AutoTagger.new(stage, working_directory)
+      tag = tagger.latest_tag
+      commit = tagger.repository.commit_for(tag)
+      entries << "#{stage.to_s.ljust(10, " ")} #{tag.to_s.ljust(30, " ")} #{commit.to_s}"
+    end
+    entries
+  end
+
+end

data/lib/auto_tagger/commander.rb

@@ -0,0 +1,15 @@
+class Commander
+  class << self
+    def execute(path, cmd)
+      `#{command_in_context(path, cmd)}`
+    end
+
+    def execute!(path, cmd)
+      system command_in_context(path, cmd)
+    end
+
+    def command_in_context(path, cmd)
+      "cd #{path} && #{cmd}"
+    end
+  end
+end

data/lib/auto_tagger/repository.rb

@@ -0,0 +1,42 @@
+class Repository
+
+  class NoPathProvidedError < StandardError; end
+  class NoSuchPathError < StandardError; end
+  class InvalidGitRepositoryError < StandardError; end
+  class GitCommandFailedError < StandardError; end
+
+  attr_reader :path
+
+  def initialize(path)
+    if path.to_s.strip == ""
+      raise NoPathProvidedError
+    elsif ! File.exists?(path)
+      raise NoSuchPathError
+    elsif ! File.exists?(File.join(path, ".git"))
+      raise InvalidGitRepositoryError
+    else
+      @path = path
+    end
+  end
+
+  def ==(other)
+    other.is_a?(Repository) && other.path == path
+  end
+
+  def tags
+    @tags ||= Tag.new(self)
+  end
+
+  def commit_for(tag)
+    Commander.execute(path, "git --no-pager log #{tag} --pretty=oneline -1")
+  end
+
+  def run(cmd)
+    Commander.execute(path, cmd)
+  end
+
+  def run!(cmd)
+    Commander.execute!(path, cmd) || raise(GitCommandFailedError)
+  end
+
+end

data/lib/auto_tagger/stage_manager.rb

@@ -0,0 +1,23 @@
+class StageManager
+
+  class NoStagesSpecifiedError < StandardError
+    def message
+      "You must set the :stages variable to an array, like set :stages, [:ci, :demo]"
+    end
+  end
+
+  attr_reader :stages
+
+  def initialize(stages)
+    raise NoStagesSpecifiedError unless stages && stages.is_a?(Array)
+    @stages = stages
+  end
+
+  def previous_stage(stage)
+    if stage
+      index = stages.index(stage) - 1
+      stages[index] if index > -1
+    end
+  end
+
+end

data/lib/auto_tagger/tag.rb

@@ -0,0 +1,41 @@
+# git --no-pager log --pretty=oneline -1
+# git tag -a -m 'Successful continuous integration build on #{timestamp}' #{tag_name}"
+class Tag
+
+  attr_reader :repository
+
+  def initialize(repository)
+    @repository = repository
+  end
+
+  def find_all
+    repository.run("git tag").split("\n")
+  end
+
+  def fetch
+    repository.run! "git fetch origin --tags"
+  end
+
+  def latest_from(stage)
+    find_all.select{|tag| tag =~ /^#{stage}\//}.sort.last
+  end
+
+  def push
+    repository.run! "git push origin --tags"
+  end
+
+  def create(stage, commit = nil)
+    tag_name = name_for(stage)
+    cmd = "git tag #{tag_name}"
+    cmd += " #{commit}" if commit
+    repository.run! cmd
+    tag_name
+  end
+
+  private
+
+  def name_for(stage)
+    "%s/%s" % [stage, Time.now.utc.strftime('%Y%m%d%H%M%S')]
+  end
+
+end

data/lib/auto_tagger.rb

@@ -0,0 +1,10 @@
+[
+  'commander',
+  'repository',
+  'tag',
+  'auto_tagger',
+  'stage_manager',
+  'capistrano_helper'
+].each do |file|
+  require File.expand_path(File.join(File.dirname(__FILE__), "auto_tagger", file))
+end

data/recipes/release_tagger.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "auto_tagger"))
+
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :release_tagger do
+    desc %Q{
+      Sets the branch to the latest tag from the previous stage.
+      Use -Shead=true to set the branch to master, -Stag=<tag> to specify the tag explicitly.
+    }
+    task :set_branch do
+      if branch_name = CapistranoHelper.new(variables).branch
+        set :branch, branch_name
+        logger.info "setting branch to #{branch_name}"
+      else
+        logger.info "AUTO TAGGER: skipping auto-assignment of branch.  Branch will remain the default.}"
+      end
+    end
+
+    desc %Q{Prints the most current tags from all stages}
+    task :print_latest_tags, :roles => :app do
+      logger.info "AUTO TAGGER: release tag history is:"
+      entries = CapistranoHelper.new(variables).release_tag_entries
+      entries.each do |entry|
+        logger.info entry
+      end
+    end
+
+    desc %Q{Reads the text file with the latest tag from the shared directory}
+    task :read_tag_from_shared, :roles => :app do
+      logger.info "AUTO TAGGER: latest tag deployed to this environment was:"
+      run "cat #{shared_path}/released_git_tag.txt"
+    end
+
+    desc %Q{Writes the tag name to a file in the shared directory}
+    task :write_tag_to_shared, :roles => :app do
+      if exists?(:branch)
+        logger.info "AUTO TAGGER: writing tag to shared text file on remote server"
+        run "echo '#{branch}' > #{shared_path}/released_git_tag.txt"
+      else
+        logger.info "AUTO TAGGER: no branch available.  Text file was not written to server"
+      end
+    end
+
+    desc %Q{Creates a tag using the stage variable}
+    task :create_tag, :roles => :app do
+      if variables[:stage]
+        previous_tag = AutoTagger.new(StageManager.new(autotagger_stages).previous_stage(stage), Dir.pwd).latest_tag
+        tag_name = AutoTagger.new(variables[:stage], variables[:working_directory]).create_tag(previous_tag)
+        logger.info "AUTO TAGGER created tag #{tag_name} from #{previous_tag.inspect}"
+      else
+        tag_name = AutoTagger.new(:production, variables[:working_directory]).create_tag
+        logger.info "AUTO TAGGER created tag #{tag_name}"
+      end
+    end
+  end
+end

data/spec/auto_tagger/auto_tagger_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AutoTagger do
+  before(:each) do
+    stub(Dir).pwd { File.join(File.dirname(__FILE__), '..', '..') }
+  end
+
+  describe ".new" do
+    it "blows up if you don't pass an stage" do
+      proc do
+        AutoTagger.new(nil)
+      end.should raise_error(AutoTagger::EnvironmentCannotBeBlankError)
+    end
+
+    it "sets the stage when it's passed" do
+      AutoTagger.new("ci").stage.should == "ci"
+    end
+
+    it "sets the path to Dir.pwd when nil" do
+      mock(Dir).pwd { "/foo" }
+      mock(Repository).new("/foo")
+      AutoTagger.new("ci")
+    end
+
+    it "expands the path when the path is passed" do
+      mock(Repository).new(File.expand_path("."))
+      AutoTagger.new("ci", ".")
+    end
+
+    it "exposes the working directory" do
+      mock(Repository).new(File.expand_path("."))
+      AutoTagger.new("ci", ".").working_directory.should == File.expand_path(".")
+    end
+  end
+
+  describe "#create_tag" do
+    it "generates the correct commands" do
+      time = Time.local(2001,1,1)
+      mock(Time).now.once {time}
+      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
+      mock(File).exists?(anything).twice { true }
+
+      mock(Commander).execute!("/foo", "git fetch origin --tags") {true}
+      mock(Commander).execute!("/foo", "git tag ci/#{timestamp}") {true}
+      mock(Commander).execute!("/foo", "git push origin --tags")  {true}
+
+      AutoTagger.new("ci", "/foo").create_tag
+    end
+
+    it "allows you to base it off an existing tag or commit" do
+      time = Time.local(2001,1,1)
+      mock(Time).now.once {time}
+      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
+      mock(File).exists?(anything).twice { true }
+
+      mock(Commander).execute!("/foo", "git fetch origin --tags") {true}
+      mock(Commander).execute!("/foo", "git tag ci/#{timestamp} guid") {true}
+      mock(Commander).execute!("/foo", "git push origin --tags")  {true}
+
+      AutoTagger.new("ci", "/foo").create_tag("guid")
+    end
+
+    it "returns the tag that was created" do
+      time = Time.local(2001,1,1)
+      mock(Time).now.once {time}
+      timestamp = time.utc.strftime('%Y%m%d%H%M%S')
+      mock(File).exists?(anything).twice { true }
+      mock(Commander).execute!(anything, anything).times(any_times) {true}
+
+      AutoTagger.new("ci", "/foo").create_tag.should == "ci/#{timestamp}"
+    end
+  end
+
+  describe "#latest_tag" do
+    it "generates the correct commands" do
+      mock(File).exists?(anything).twice { true }
+
+      mock(Commander).execute!("/foo", "git fetch origin --tags") {true}
+      mock(Commander).execute("/foo", "git tag") { "ci_01" }
+
+      AutoTagger.new("ci", "/foo").latest_tag
+    end
+  end
+
+end

data/spec/auto_tagger/capistrano_helper_spec.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CapistranoHelper do
+
+  describe ".new" do
+    it "blows up if there are no stages" do
+      proc do
+        CapistranoHelper.new({})
+      end.should raise_error(StageManager::NoStagesSpecifiedError)
+    end
+  end
+
+  describe "#variables" do
+    it "returns all variables" do
+      CapistranoHelper.new({:autotagger_stages => [:bar]}).variables.should == {:autotagger_stages => [:bar]}
+    end
+  end
+
+  describe "#working_directory" do
+    it "returns the hashes' working directory value" do
+      CapistranoHelper.new({:autotagger_stages => [:bar], :working_directory => "/foo"}).working_directory.should == "/foo"
+    end
+
+    it "defaults to Dir.pwd if it's not set, or it's nil" do
+      mock(Dir).pwd { "/bar" }
+      CapistranoHelper.new({:autotagger_stages => [:bar]}).working_directory.should == "/bar"
+    end
+  end
+
+  describe "#stage" do
+    it "returns the hashes' current stage value" do
+      CapistranoHelper.new({:autotagger_stages => [:bar], :stage => :bar}).stage.should == :bar
+      CapistranoHelper.new({:autotagger_stages => [:bar]}).stage.should be_nil
+    end
+  end
+
+  describe "#release_tag_entries" do
+    it "returns a column-justifed version of all the commits" do
+      mock(Commander).execute("/foo", "git tag").times(any_times) { "ci/01\nstaging/01\nproduction/01" }
+      mock(Commander).execute("/foo", "git --no-pager log ci/01 --pretty=oneline -1") { "guid1" }
+      mock(Commander).execute("/foo", "git --no-pager log staging/01 --pretty=oneline -1") { "guid2" }
+      mock(Commander).execute("/foo", "git --no-pager log production/01 --pretty=oneline -1") { "guid3" }
+      mock(Commander).execute!("/foo", "git fetch origin --tags").times(any_times) { true }
+      mock(File).exists?(anything).times(any_times) {true}
+
+      variables = {
+        :working_directory => "/foo",
+        :autotagger_stages => [:ci, :staging, :production]
+      }
+      histories = CapistranoHelper.new(variables).release_tag_entries
+      histories.length.should == 3
+      histories[0].should include("ci/01", "guid1")
+      histories[1].should include("staging/01", "guid2")
+      histories[2].should include("production/01", "guid3")
+    end
+
+    it "ignores tags delimited with '_'" do
+      mock(Commander).execute("/foo", "git tag").times(any_times) { "ci/01\nci_02" }
+      mock(Commander).execute("/foo", "git --no-pager log ci/01 --pretty=oneline -1") { "guid1" }
+      mock(Commander).execute!("/foo", "git fetch origin --tags").times(any_times) { true }
+      mock(File).exists?(anything).times(any_times) {true}
+
+      variables = {
+        :working_directory => "/foo",
+        :autotagger_stages => [:ci]
+      }
+      histories = CapistranoHelper.new(variables).release_tag_entries
+      histories.length.should == 1
+      histories[0].should include("ci/01", "guid1")
+    end
+  end
+
+  describe "#branch" do
+    describe "with :head and :branch specified" do
+      it "returns master" do
+        variables = {
+          :autotagger_stages => [:bar],
+          :head => nil,
+          :branch => "foo"
+        }
+        CapistranoHelper.new(variables).branch.should == "foo"
+      end
+    end
+
+    describe "with :head specified, but no branch specified" do
+      it "returns master" do
+        variables = {
+          :autotagger_stages => [:bar],
+          :head => nil
+        }
+        CapistranoHelper.new(variables).branch.should == nil
+      end
+    end
+
+    describe "with :branch specified" do
+      it "returns the value of branch" do
+        variables = {
+          :autotagger_stages => [:bar],
+          :branch => "foo"
+        }
+        CapistranoHelper.new(variables).branch.should == "foo"
+      end
+    end
+
+    describe "with a previous stage with a tag" do
+      it "returns the latest tag for the previous stage" do
+        variables = {
+          :autotagger_stages => [:foo, :bar],
+          :stage => :bar,
+          :branch => "master",
+          :working_directory => "/foo"
+        }
+        tagger = Object.new
+        mock(tagger).latest_tag { "foo_01" }
+        mock(AutoTagger).new(:foo, "/foo") { tagger }
+        CapistranoHelper.new(variables).branch.should == "foo_01"
+      end
+    end
+
+    describe "with no branch and a previous stage with no tag" do
+      it "returns nil" do
+        variables = {
+          :autotagger_stages => [:foo, :bar],
+          :stage => :bar,
+          :working_directory => "/foo"
+        }
+        tagger = Object.new
+        mock(tagger).latest_tag { nil }
+        mock(AutoTagger).new(:foo, "/foo") { tagger }
+        CapistranoHelper.new(variables).branch.should == nil
+      end
+    end
+
+    describe "with no branch and previous stage" do
+      it "returns nil" do
+        variables = {
+          :autotagger_stages => [:bar],
+          :stage => :bar
+        }
+        CapistranoHelper.new(variables).previous_stage.should be_nil
+        CapistranoHelper.new(variables).branch.should == nil
+      end
+    end
+  end
+
+end

data/spec/auto_tagger/commander_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Commander do
+  describe ".execute" do
+    it "execute the command and returns the results" do
+      mock(Commander).`("cd /foo && ls") { "" } #`
+      Commander.execute("/foo", "ls")
+    end
+  end
+
+  describe "system" do
+    it "executes and doesn't return anything" do
+      mock(Commander).system("cd /foo && ls")
+      Commander.execute!("/foo", "ls")
+    end
+  end
+end

data/spec/auto_tagger/repository_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Repository do
+  describe ".new" do
+    it "sets the repo" do
+      mock(File).exists?(anything).twice { true }
+      repo = Repository.new("/foo")
+      repo.path.should == "/foo"
+    end
+
+    it "raises an error when the path is blank" do
+      proc do
+        Repository.new(" ")
+      end.should raise_error(Repository::NoPathProvidedError)
+    end
+
+    it "raises an error when the path is nil" do
+      proc do
+        Repository.new(nil)
+      end.should raise_error(Repository::NoPathProvidedError)
+    end
+
+    it "raises an error with a file that doesn't exist" do
+      mock(File).exists?("/foo") { false }
+      proc do
+        Repository.new("/foo")
+      end.should raise_error(Repository::NoSuchPathError)
+    end
+
+    it "raises an error with a non-git repository" do
+      mock(File).exists?("/foo") { true }
+      mock(File).exists?("/foo/.git") { false }
+      proc do
+        Repository.new("/foo")
+      end.should raise_error(Repository::InvalidGitRepositoryError)
+    end
+  end
+
+  describe "#==" do
+    it "compares paths" do
+      mock(File).exists?(anything).times(any_times) { true }
+      Repository.new("/foo").should_not == "/foo"
+      Repository.new("/foo").should_not == Repository.new("/bar")
+      Repository.new("/foo").should == Repository.new("/foo")
+    end
+  end
+
+  describe "#run" do
+    it "sends the correct command" do
+      mock(File).exists?(anything).twice { true }
+      mock(Commander).execute("/foo", "bar")
+      Repository.new("/foo").run("bar")
+    end
+  end
+
+  describe "run!" do
+    it "sends the correct command" do
+      mock(File).exists?(anything).twice { true }
+      mock(Commander).execute!("/foo", "bar") { true }
+      Repository.new("/foo").run!("bar")
+    end
+
+    it "raises an exception if it the command returns false" do
+      mock(File).exists?(anything).twice { true }
+      mock(Commander).execute!("/foo", "bar") { false }
+      proc do
+        Repository.new("/foo").run!("bar")
+      end.should raise_error(Repository::GitCommandFailedError)
+    end
+  end
+
+end

data/spec/auto_tagger/stage_manager_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe StageManager do
+
+  describe ".new" do
+    [nil, ""].each do |value|
+      it "blows up if there are stages == #{value.inspect}" do
+        proc do
+          StageManager.new(value)
+        end.should raise_error(StageManager::NoStagesSpecifiedError)
+      end
+    end
+  end
+
+  describe "#previous_stage" do
+    it "returns the previous stage if there is more than one stage, and there is a current stage" do
+      StageManager.new([:foo, :bar]).previous_stage(:bar).should == :foo
+    end
+
+    it "returns nil if there is no previous stage" do
+      StageManager.new([:bar]).previous_stage(:bar).should be_nil
+    end
+
+    it "returns nil if there is no current stage" do
+      StageManager.new([:bar]).previous_stage(nil).should be_nil
+    end
+  end
+
+
+end

data/spec/auto_tagger/tag_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Tag do
+
+  before(:each) do
+    @repository = Object.new
+  end
+
+  describe ".new" do
+    it "sets the repository" do
+      Tag.new(@repository).repository.should == @repository
+    end
+  end
+
+  describe "#find_all" do
+    it "returns an array of tags" do
+      mock(@repository).run("git tag") { "ci_01\nci_02" }
+      Tag.new(@repository).find_all.should == ["ci_01", "ci_02"]
+    end
+
+    it "returns an empty array if there are none" do
+      mock(@repository).run("git tag") { "" }
+      Tag.new(@repository).find_all.should be_empty
+    end
+  end
+
+  describe "#latest_from" do
+    before do
+      @tag = Tag.new(@repository)
+      mock(@tag).find_all { ["ci/01", "ci/02"] }
+    end
+
+    it "returns the latest tag that starts with the specified stage" do
+      @tag.latest_from(:ci).should == "ci/02"
+    end
+
+    it "returns nil if none match" do
+      @tag.latest_from(:staging).should be_nil
+    end
+  end
+
+  describe "#fetch_tags" do
+    it "sends the correct command" do
+      mock(@repository).run!("git fetch origin --tags")
+      Tag.new(@repository).fetch
+    end
+  end
+
+  describe "#push" do
+    it "sends the correct command" do
+      mock(@repository).run!("git push origin --tags")
+      Tag.new(@repository).push
+    end
+  end
+
+  describe "#create" do
+    it "creates the right command and returns the name" do
+      time = Time.local(2001,1,1)
+      mock(Time).now.once {time}
+      tag_name = "ci/#{time.utc.strftime('%Y%m%d%H%M%S')}"
+      mock(@repository).run!("git tag #{tag_name}")
+      Tag.new(@repository).create("ci").should == tag_name
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'spec'
+require 'rr'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "auto_tagger"))
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: auto_tagger
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- Jeff Dean
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-28 00:00:00 -04:00
+default_executable: autotag
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.3
+    version: 
+description: 
+email: 
+executables: 
+- autotag
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/auto_tagger/auto_tagger.rb
+- lib/auto_tagger/capistrano_helper.rb
+- lib/auto_tagger/commander.rb
+- lib/auto_tagger/repository.rb
+- lib/auto_tagger/stage_manager.rb
+- lib/auto_tagger/tag.rb
+- lib/auto_tagger.rb
+- recipes/release_tagger.rb
+- bin/autotag
+- spec/auto_tagger/auto_tagger_spec.rb
+- spec/auto_tagger/capistrano_helper_spec.rb
+- spec/auto_tagger/commander_spec.rb
+- spec/auto_tagger/repository_spec.rb
+- spec/auto_tagger/stage_manager_spec.rb
+- spec/auto_tagger/tag_spec.rb
+- spec/spec_helper.rb
+- MIT-LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/zilkey/git_tagger/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- recipes
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 2
+summary: Helps you automatically create tags for each stage in a multi-stage deploment and deploy from the latest tag from the previous environment
+test_files: []
+