factorylabs-auto_tagger 0.1.1

data/lib/auto_tagger/recipes.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "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]
+        tag_name = AutoTagger.new(variables[:stage], variables[:working_directory]).create_tag(real_revision)
+        logger.info "AUTO TAGGER created tag #{tag_name} from #{real_revision}"
+      else
+        tag_name = AutoTagger.new(:production, variables[:working_directory]).create_tag
+        logger.info "AUTO TAGGER created tag #{tag_name}"
+      end
+    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.map{|stage| stage.to_s }
+  end
+
+  def previous_stage(stage)
+    if stage
+      index = stages.index(stage.to_s) - 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/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