auto_tagger 0.1.5 → 0.2.0

data/features/step_definitions/autotag_steps.rb

@@ -1,28 +1,28 @@
 Given /^a repo$/ do
-  puts
-  helpers = StepHelpers.new
-  helpers.create_git_repo
-  helpers.create_app
-  @tags = helpers.tags
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.create_git_repo
+    helpers.create_app
+    @refs = helpers.refs
+  end
 end
 
 When /^I run autotag with no arguments$/ do
-  puts
-  helpers = StepHelpers.new
-  @output, @exit_code = helpers.run_autotag
-  @tags = helpers.tags
-  @exit_code = helpers.exit_code
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    @output, @exit_code = helpers.run_autotag
+    @refs = helpers.refs
+    @exit_code = helpers.exit_code
+  end
 end
 
 When /^I run autotag with "([^\"]*)"$/ do |args|
-  puts
-  helpers = StepHelpers.new
-  @output, @exit_code = helpers.run_autotag(args)
-  @tags = helpers.tags
-  @exit_code = helpers.exit_code
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    @output = helpers.run_autotag(args)
+    @refs = helpers.refs
+    @exit_code = helpers.exit_code
+  end
 end
 
 Then /^I should see "([^\"]*)"$/ do |text|
@@ -34,18 +34,23 @@ Then /^the exit code should be "(\d+)"$/ do |code|
 end
 
 Then /^no tags should be created$/ do
-  @tags.strip.should == ""
+  @refs.strip.should == ""
 end
 
 Then /^a "([^\"]*)" tag should be added to git$/ do |stage|
   helpers = StepHelpers.new
-  helpers.tags.starts_with?(stage).should be_true
+  helpers.refs.split("\n").last.should match(/\/#{stage}\//)
 end
 
 Then /^a "([^\"]*)" tag should be created$/ do |prefix|
-  @tags.strip.split("\n").any?{|tag| tag.starts_with?("demo")}.should be_true
+  @refs.strip.split("\n").any? { |ref| ref =~ /\/demo\// }.should be_true
+end
+
+Then /^a hyphen-delimited "([^\"]*)" tag should be created$/ do |prefix|
+  tag = @refs.strip.split("\n").detect { |ref| ref =~ /\/demo\// }
+  tag.split(" ").last.split("/").last.split("-").first.should == Date.today.year.to_s
 end
 
-Then /^exit code should be (\d*)$/ do |exit_code|
+Then /^(?:the )?exit code should be (\d*)$/ do |exit_code|
   @exit_code.should == exit_code.to_i
 end

data/features/step_definitions/deployment_steps.rb

@@ -1,53 +1,61 @@
 Given /^a three-stage app using single deploy file$/ do
-  puts
-  helpers = StepHelpers.new
-  helpers.create_app_with_single_deploy_file([:ci, :staging, :production])
-  puts
-  @tags = helpers.tags
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.create_app_with_single_deploy_file([:ci, :staging, :production])
+    @refs = helpers.refs
+  end
 end
 
 Given /^a one\-stage app using single deploy file with the following environments:$/ do |table|
-  puts
-  helpers = StepHelpers.new
-  helpers.create_app_with_single_deploy_file table.raw.map(&:first)
-  puts
-  @tags = helpers.tags
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.create_app_with_single_deploy_file table.raw.map(&:first)
+    @refs = helpers.refs
+  end
 end
 
 Given /^a three-stage app using cap-multistage$/ do
-  puts
-  helpers = StepHelpers.new
-  helpers.create_app_with_cap_ext_multistage
-  puts
-  @tags = helpers.tags
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.create_app_with_cap_ext_multistage
+    @refs = helpers.refs
+  end
+end
+
+Given /^an app with deploy file that uses the dsl$/ do
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.create_app_with_dsl
+    @refs = helpers.refs
+  end
 end
 
 Given /^a ci tag$/ do
-  puts
-  helpers = StepHelpers.new
-  helpers.autotag("ci")
-  @tags = helpers.tags
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.autotag("ci")
+    @refs = helpers.refs
+  end
 end
 
 When /^I deploy to (.*)$/ do |environment|
-  puts
-  helpers = StepHelpers.new
-  helpers.deploy(environment)
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.deploy(environment)
+  end
 end
 
 When /^I deploy$/ do
-  puts
-  helpers = StepHelpers.new
-  helpers.deploy
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    helpers.deploy
+  end
 end
 
 Then /^a tag should be added to git$/ do
-  puts
-  helpers = StepHelpers.new
-  new_tags = helpers.tags
-  @tags.length.should < new_tags.length
-  puts
+  with_or_without_debugging do
+    helpers = StepHelpers.new
+    new_tags = helpers.refs
+    @refs.length.should < new_tags.length
+  end
 end

data/features/support/env.rb

@@ -1,7 +1,50 @@
-require 'spec'
+require 'rspec'
 require 'erb'
 require 'etc'
-require 'activesupport'
+
+class String
+  def starts_with?(prefix)
+    self[0, prefix.length] == prefix
+  end
+end
+
+module Silencers
+
+  def with_or_without_debugging
+    if ENV['AUTO_TAGGER_DEBUG'] == "true"
+      puts
+      yield
+      puts
+    else
+      silence_stream(STDOUT) do
+        silence_stream(STDERR) do
+          silence_warnings do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end
+
+World(Silencers)
 
 Before do
   StepHelpers.new.reset

data/features/support/step_helpers.rb

@@ -24,10 +24,19 @@ class StepHelpers
     create_single_deploy_file(environments)
   end
 
+  def create_app_with_dsl
+    create_git_repo
+    create_app
+    capify_app
+    create_dsl_deploy_file
+  end
+
   def run_autotag(args = nil)
     cmd = "cd #{app_dir} && ../../bin/autotag"
     cmd += " #{args}" if args
+    cmd += " 2>&1"
     output = `#{cmd}`
+    puts output
     @exit_code = $?.exitstatus
     return output
   end
@@ -55,11 +64,11 @@ class StepHelpers
     system "cd #{app_dir} && git tag #{stage}/#{Time.now.utc.strftime('%Y%m%d%H%M%S')} && git push origin --tags"
   end
 
-  def tags
-    system "cd #{app_dir} && git fetch origin --tags"
-    tags = `cd #{app_dir} && git tag`
-    puts tags
-    tags
+  def refs(namespace = "tags")
+    system "cd #{app_dir} && git fetch origin refs/#{namespace}/*:refs/#{namespace}/*"
+    refs = `cd #{app_dir} && git show-ref | grep #{namespace}`
+    puts refs
+    refs
   end
 
   def create_app
@@ -86,22 +95,41 @@ class StepHelpers
   end
 
   def create_single_deploy_file(environments)
+
+    # ERB variables
     repository = repo_dir
     deploy_to = File.join(test_files_dir, "deployed")
     git_location = `which git`.strip
     user = Etc.getlogin
 
     path = File.expand_path(File.join(__FILE__, "..", "..", "templates", "deploy.erb"))
-    #puts "TRACE %s:%s" % [__FILE__, __LINE__]
-    #puts path
-    #puts File.exists?(path)
+    template = ERB.new File.read(path)
+    output = template.result(binding)
+    File.open(File.join(app_dir, "config", "deploy.rb"), 'w') {|f| f.write(output) }
+  end
+
+  def create_dsl_deploy_file
 
+    # ERB variables
+    repository = repo_dir
+    deploy_to = File.join(test_files_dir, "deployed")
+    git_location = `which git`.strip
+    user = Etc.getlogin
+    environments = ["ci", "staging"]
+
+    path = File.expand_path(File.join(__FILE__, "..", "..", "templates", "deploy_dsl.erb"))
     template = ERB.new File.read(path)
     output = template.result(binding)
+
+    puts "#{__FILE__}:#{__LINE__}"
+    p output
+
     File.open(File.join(app_dir, "config", "deploy.rb"), 'w') {|f| f.write(output) }
   end
 
   def create_cap_ext_multistage_deploy_files
+
+    # ERB variables
     repository = repo_dir
     deploy_to = File.join(test_files_dir, "deployed")
     git_location = `which git`.strip
@@ -109,11 +137,9 @@ class StepHelpers
     environments = [:ci, :staging, :production]
 
     path = File.expand_path(File.join(__FILE__, "..", "..", "templates", "cap_ext_deploy.erb"))
-
     template = ERB.new File.read(path)
     output = template.result(binding)
     File.open(File.join(app_dir, "config", "deploy.rb"), 'w') {|f| f.write(output) }
-
     %w(staging production).each do |stage|
       create_cap_ext_multistage_deploy_stage_file(stage)
     end
@@ -122,11 +148,9 @@ class StepHelpers
   def create_cap_ext_multistage_deploy_stage_file(stage)
     deploy_subdir = File.join(app_dir, "config", "deploy")
     FileUtils.mkdir_p deploy_subdir
-
     template_path = File.expand_path(File.join(__FILE__, "..", "..", "templates", "stage.erb"))
     template = ERB.new File.read(template_path)
     output = template.result(binding)
-
     File.open(File.join(deploy_subdir, "#{stage}.rb"), 'w') {|f| f.write(output) }
   end
 

data/features/templates/deploy.erb

@@ -31,4 +31,4 @@ end
 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"
+after  "deploy", "release_tagger:print_latest_tag"

data/lib/auto_tagger/base.rb

@@ -1,26 +1,157 @@
 module AutoTagger
-  class EnvironmentCannotBeBlankError < StandardError; end
-  
-  class Runner
-    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
+
+  def self.version
+    File.read(File.expand_path(File.join(__FILE__, "/../../../VERSION")))
+  end
+
+  class Base
+    class StageCannotBeBlankError < StandardError;
+    end
+
+    def self.items_to_remove(array, keep)
+      max = array.length - keep
+      max = 0 if max <= 0
+      array[0...max]
+    end
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def repo
+      @repo ||= AutoTagger::Git::Repo.new configuration.working_directory,
+                                          :execute_commands => !configuration.dry_run?,
+                                          :verbose => configuration.verbose?,
+                                          :executable => configuration.executable
+    end
+
+    def last_ref_from_previous_stage
+      return unless previous_stage
+      refs_for_stage(previous_stage).last
+    end
+
+    def create_ref(commit = nil)
+      ensure_stage
+      fetch
+      new_tag = repo.refs.create(commit || repo.latest_commit_sha, ref_name)
+      push
       new_tag
     end
 
-    def latest_tag
-      repository.tags.fetch
-      repository.tags.latest_from(stage)
+    def pattern
+      "refs/#{configuration.ref_path}/*"
+    end
+
+    private :pattern
+
+    def fetch
+      repo.refs.fetch(pattern, configuration.remote) if configuration.fetch_refs?
+    end
+
+    private :fetch
+
+    def push
+      repo.refs.push(pattern, configuration.remote) if configuration.push_refs?
+    end
+
+    private :push
+
+    def cleanup
+      refs = refs_to_remove
+      delete_local_refs(refs)
+      delete_remote_refs(refs) if configuration.push_refs?
+      refs.length
+    end
+
+    def delete_locally
+      refs = refs_to_remove
+      refs.each { |ref| ref.delete_locally }
+      refs.length
+    end
+
+    def delete_local_refs(refs)
+      refs.each { |ref| ref.delete_locally }
+    end
+
+    private :delete_local_refs
+
+    def delete_on_remote
+      refs = refs_to_remove
+      delete_remote_refs(refs)
+      refs.length
+    end
+
+    def delete_remote_refs(refs)
+      if refs.any?
+        cmd = ["push #{configuration.remote}"]
+        cmd += refs.map { |ref| ":#{ref.name}" }
+        repo.exec cmd.join(" ")
+      end
+    end
+
+    private :delete_remote_refs
+
+    def list
+      ensure_stage
+      fetch
+      refs_for_stage(configuration.stage)
+    end
+
+    def release_tag_entries
+      configuration.stages.map do |stage|
+        refs_for_stage(stage).last
+      end
+    end
+
+    def refs_for_stage(stage)
+      raise StageCannotBeBlankError if stage.to_s.strip == ""
+      ref_path = Regexp.escape(configuration.ref_path)
+      matcher = /refs\/#{ref_path}\/#{Regexp.escape(stage)}\/.*/
+      repo.refs.all.select do |ref|
+        (ref.name =~ matcher) ? ref : nil
+      end
+    end
+
+    private
+
+    def refs_to_remove
+      self.class.items_to_remove(refs_for_stage(configuration.stage), configuration.refs_to_keep)
+    end
+
+    def previous_stage
+      return unless configuration.stage
+      index = configuration.stages.index(configuration.stage).to_i - 1
+      configuration.stages[index] if index > -1
+    end
+
+    def configuration
+      @configuration ||= begin
+        config = AutoTagger::Configuration.new(@options)
+        # raise "Stage must be included in stages" unless config.stages.include?(config.stage)
+        config
+      end
+    end
+
+    def ref_name
+      "refs/#{configuration.ref_path}/#{configuration.stage}/#{timestamp}"
+    end
+
+    def timestamp
+      time = Time.now.utc
+      [
+        time.strftime("%Y"),
+        time.strftime("%m"),
+        time.strftime("%d"),
+        time.strftime("%H"),
+        time.strftime("%M"),
+        time.strftime("%S")
+      ].join(configuration.date_separator)
+    end
+
+    def ensure_stage
+      raise StageCannotBeBlankError if configuration.stage.to_s.strip == ""
     end
   end
 end

data/lib/auto_tagger/capistrano_helper.rb

@@ -1,40 +1,61 @@
 module AutoTagger
   class CapistranoHelper
 
-    attr_reader :variables, :stage, :working_directory
+    attr_reader :variables
+    private :variables
 
     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)
+    def auto_tagger
+      @auto_tagger ||= AutoTagger::Base.new(auto_tagger_options)
     end
 
-    def branch
+    def ref
       if variables.has_key?(:head)
         variables[:branch]
       elsif variables.has_key?(:tag)
         variables[:tag]
-      elsif previous_stage && (latest = Runner.new(previous_stage, working_directory).latest_tag)
-        latest
+      elsif variables.has_key?(:ref)
+        variables[:ref]
+      elsif auto_tagger.last_ref_from_previous_stage
+        auto_tagger.last_ref_from_previous_stage.sha
       else
         variables[:branch]
       end
     end
 
-    def release_tag_entries
-      entries = []
-      @stage_manager.stages.each do |stage|
-        tagger = Runner.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}"
+    def auto_tagger_options
+      options = {}
+      options[:stage] = variables[:auto_tagger_stage] || variables[:stage]
+      options[:stages] = stages
+
+      if variables[:working_directory]
+        AutoTagger::Deprecator.warn(":working_directory is deprecated.  Please use :auto_tagger_working_directory.")
+        options[:path] = variables[:working_directory]
+      else
+        options[:path] = variables[:auto_tagger_working_directory]
+      end
+
+      [
+        :date_separator, :push_refs, :fetch_refs, :remote, :ref_path, :offline,
+        :dry_run, :verbose, :refs_to_keep, :executable, :opts_file
+      ].each do |key|
+        options[key] = variables[:"auto_tagger_#{key}"]
+      end
+
+      options
+    end
+
+    def stages
+      if variables[:autotagger_stages]
+        AutoTagger::Deprecator.warn(":autotagger_stages is deprecated.  Please use :auto_tagger_stages.")
+        stages = variables[:autotagger_stages]
+      else
+        stages = variables[:auto_tagger_stages] || variables[:stages] || []
       end
-      entries
+      stages.map { |stage| stage.to_s }
     end
 
   end

data/lib/auto_tagger/command_line.rb

@@ -0,0 +1,65 @@
+module AutoTagger
+  class CommandLine
+
+    def initialize(args)
+      @args = args
+    end
+
+    def execute
+      case options[:command]
+        when :version
+          [true, "AutoTagger version #{AutoTagger.version}"]
+        when :help
+          [true, options[:help_text]]
+        when :cleanup
+          begin
+            purged = AutoTagger::Base.new(options).cleanup
+            [true, "Deleted: #{purged}"]
+          rescue AutoTagger::Base::StageCannotBeBlankError
+            [false, "You must provide a stage"]
+          end
+        when :delete_locally
+          begin
+            purged = AutoTagger::Base.new(options).delete_locally
+            [true, "Deleted: #{purged}"]
+          rescue AutoTagger::Base::StageCannotBeBlankError
+            [false, "You must provide a stage"]
+          end
+        when :delete_on_remote
+          begin
+            purged = AutoTagger::Base.new(options).delete_on_remote
+            [true, "Deleted: #{purged}"]
+          rescue AutoTagger::Base::StageCannotBeBlankError
+            [false, "You must provide a stage"]
+          end
+        when :list
+          begin
+            [true, AutoTagger::Base.new(options).list.join("\n")]
+          rescue AutoTagger::Base::StageCannotBeBlankError
+            [false, "You must provide a stage"]
+          end
+        when :config
+          [true, AutoTagger::Configuration.new(options).settings.map { |key, value| "#{key} : #{value}" }.join("\n")]
+        else
+          begin
+            create_message = []
+            if options[:deprecated]
+              create_message << AutoTagger::Deprecator.string("Please use `autotag create #{options[:stage]}` instead")
+            end
+            ref = AutoTagger::Base.new(options).create_ref
+            create_message << "Created ref #{ref.name}"
+            [true, create_message.join("\n")]
+          rescue AutoTagger::Base::StageCannotBeBlankError
+            [false, "You must provide a stage"]
+          end
+      end
+    end
+
+    private
+
+    def options
+      @options ||= AutoTagger::Options.from_command_line(@args)
+    end
+
+  end
+end