auto_tagger 0.1.5 → 0.2.0

data/lib/auto_tagger/commander.rb

@@ -1,19 +1,30 @@
 module AutoTagger
   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 initialize(path, verbose)
+      @path = path
+      @verbose = verbose
+    end
+
+    def print(cmd)
+      puts command_in_context(cmd)
+    end
 
-      private
+    def read(cmd)
+      puts command_in_context(cmd) if @verbose
+      `#{command_in_context(cmd)}`
+    end
 
-      def command_in_context(path, cmd)
-        "cd #{path} && #{cmd}"
-      end
+    def execute(cmd)
+      puts command_in_context(cmd) if @verbose
+      system command_in_context(cmd)
     end
+
+    private
+    
+    def command_in_context(cmd)
+      "cd #{@path} && #{cmd}"
+    end
+
   end
 end

data/lib/auto_tagger/configuration.rb

@@ -0,0 +1,88 @@
+module AutoTagger
+
+  class Configuration
+
+    class InvalidRefPath < StandardError
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def working_directory
+      File.expand_path(@options[:path] || Dir.pwd)
+    end
+
+    def opts_file
+      file = @options[:opts_file] || ".auto_tagger"
+      File.expand_path File.join(working_directory, file)
+    end
+
+    def file_settings
+      return {} unless File.exists?(opts_file)
+      args = File.read(opts_file).to_s.split("\n").map { |line| line.strip }
+      args.reject! { |line| line == "" }
+      AutoTagger::Options.from_file(args)
+    end
+
+    def settings
+      file_settings.merge(@options)
+    end
+
+    def stages
+      stages = settings[:stages] || []
+      stages = stages.to_s.split(",").map { |stage| stage.strip } if stages.is_a?(String)
+      stages.reject { |stage| stage.to_s == "" }
+    end
+
+    def stage
+      settings[:stage] || stages.last
+    end
+
+    def date_separator
+      settings[:date_separator] ||= ""
+    end
+
+    def dry_run?
+      settings.fetch(:dry_run, false)
+    end
+
+    def verbose?
+      settings.fetch(:verbose, false)
+    end
+
+    def offline?
+      settings.fetch(:offline, false)
+    end
+
+    def fetch_refs?
+      !offline? && settings.fetch(:fetch_refs, true)
+    end
+
+    def push_refs?
+      !offline? && settings.fetch(:push_refs, true)
+    end
+
+    def executable
+      settings[:executable] || "git"
+    end
+
+    def refs_to_keep
+      (settings[:refs_to_keep] || 1).to_i
+    end
+
+    def remote
+      settings[:remote] || "origin"
+    end
+
+    def ref_path
+      path = settings[:ref_path] || "tags"
+      if ["heads", "remotes"].include?(path)
+        raise InvalidRefPath, "#{path} is a reserved word in git.  Please use something else."
+      end
+      path
+    end
+
+  end
+
+end

data/lib/auto_tagger/deprecator.rb

@@ -0,0 +1,11 @@
+module AutoTagger
+  class Deprecator
+    def self.warn(msg)
+      puts string(msg)
+    end
+
+    def self.string(msg)
+      "AUTO_TAGGER DEPRECATION: #{msg}"
+    end
+  end
+end

data/lib/auto_tagger/git/ref.rb

@@ -0,0 +1,34 @@
+module AutoTagger
+  module Git
+    class Ref
+      attr_reader :sha, :name
+
+      # name is refs/autotags/2009292827
+      def initialize(repo, sha, name)
+        @repo, @sha, @name = repo, sha, name
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.sha == sha && other.name == name
+      end
+
+      def to_s
+        "%s %s" % [sha, name]
+      end
+
+      def delete_locally
+        @repo.exec "update-ref -d #{name}"
+      end
+
+      def delete_on_remote(remote = "origin")
+        @repo.exec "push #{remote} :#{name}"
+      end
+
+      def save
+        @repo.exec "update-ref #{name} #{sha}"
+        self
+      end
+
+    end
+  end
+end

data/lib/auto_tagger/git/ref_set.rb

@@ -0,0 +1,35 @@
+module AutoTagger
+  module Git
+    class RefSet
+
+      def initialize(repo)
+        @repo = repo
+      end
+
+      def all
+        @repo.read("show-ref").split(/\n/).map do |line|
+          sha, name = line.split
+          Ref.new(@repo, sha, name)
+        end
+      end
+
+      # name = refs/autotags/2009857463
+      # returns a ref
+      # should un-cache the refs in refset, or never memoize
+      def create(sha, name)
+        Ref.new(@repo, sha, name).save
+      end
+
+      # pattern = refs/autotags/*
+      def push(pattern, remote = "origin")
+        @repo.exec "push #{remote} #{pattern}:#{pattern}"
+      end
+
+      # pattern = refs/auto_tags/*
+      def fetch(pattern, remote = "origin")
+        @repo.exec "fetch #{remote} #{pattern}:#{pattern}"
+      end
+
+    end
+  end
+end

data/lib/auto_tagger/git/repo.rb

@@ -0,0 +1,76 @@
+module AutoTagger
+  module Git
+
+    #  A class that represents a git repo
+    #
+    #   repo.refs.create name, sha
+    #   repo.refs.all
+    #   repo.refs.push origin, pattern
+    #   repo.refs.fetch origin, pattern
+    #
+    class Repo
+
+      class NoPathProvidedError < StandardError
+      end
+
+      class NoSuchPathError < StandardError
+      end
+
+      class InvalidGitRepositoryError < StandardError
+      end
+
+      class GitCommandFailedError < StandardError
+      end
+
+      def initialize(given_path, options = {})
+        @given_path = given_path
+        @execute_commands = options.fetch(:execute_commands, true)
+        @verbose = options[:verbose]
+        @executable = options[:executable] || "git"
+      end
+
+      def path
+        return @path if @path
+        raise NoPathProvidedError if @given_path.to_s.strip == ""
+        raise NoSuchPathError if !File.exists?(@given_path)
+        raise InvalidGitRepositoryError if !File.exists?(File.join(@given_path, ".git"))
+        @path = @given_path
+      end
+
+      def refs
+        RefSet.new(self)
+      end
+      
+      def ==(other)
+        other.is_a?(AutoTagger::Git::Repo) && other.path == path
+      end
+
+      def latest_commit_sha
+        read("rev-parse HEAD").strip
+      end
+
+      def read(cmd)
+        commander.read(git_command(cmd))
+      end
+
+      def exec(cmd)
+        if @execute_commands
+          commander.execute(git_command(cmd)) || raise(GitCommandFailedError)
+        else
+          commander.print(git_command(cmd))
+        end
+      end
+
+      private
+
+      def git_command(cmd)
+        "%s %s" % [@executable, cmd]
+      end
+
+      def commander
+        AutoTagger::Commander.new(path, @verbose)
+      end
+
+    end
+  end
+end

data/lib/auto_tagger/options.rb

@@ -0,0 +1,170 @@
+module AutoTagger
+  class Options
+
+    def self.from_command_line(args)
+      options = {}
+      args.extend(::OptionParser::Arguable)
+      args.options do |opts|
+        opts.banner = [
+          "",
+          "  USAGE: autotag command [stage] [options]",
+          "",
+          "  Examples:",
+          "",
+          "    autotag help",
+          "    autotag version",
+          "    autotag create demo",
+          "    autotag create demo .",
+          "    autotag create demo ../",
+          "    autotag create ci /data/myrepo",
+          "    autotag create ci /data/myrepo --fetch-refs=false --push-refs=false",
+          "    autotag create ci /data/myrepo --offline",
+          "    autotag create ci /data/myrepo --dry-run",
+          "",
+          "    autotag list demo",
+          "",
+          "    autotag cleanup demo --refs-to-keep=2",
+          "    autotag cleanup demo --refs-to-keep=2",
+          "    autotag delete_locally demo",
+          "    autotag delete_on_remote demo",
+          "",
+          "",
+        ].join("\n")
+
+        common_options(opts, options)
+
+        opts.on("--opts-file OPTS_FILE",
+                "full path to the opts file",
+                "Defaults to working directory's .auto_tagger file",
+                "Example: /usr/local/.auto_tagger") do |o|
+          options[:opts_file] = o
+        end
+
+        opts.on_tail("-h", "--help", "-?", "You're looking at it.") do
+          options[:show_help] = true
+          options[:command] = :help
+        end
+
+        opts.on_tail("--version", "-v", "Show version") do
+          options[:show_version] = true
+          options[:command] = :version
+        end
+
+      end.parse!
+
+      case args.first.to_s.downcase
+        when "config"
+          options[:command] = :config
+        when "version"
+          options[:show_version] = true
+          options[:command] = :version
+        when * ["help", ""]
+          options[:show_help] = true
+          options[:help_text] = args.options.help
+          options[:command] = :help
+        when "cleanup"
+          options[:command] = :cleanup
+          options[:stage] = args[1]
+        when "delete_locally"
+          options[:command] = :delete_locally
+          options[:stage] = args[1]
+        when "delete_on_remote"
+          options[:command] = :delete_on_remote
+          options[:stage] = args[1]
+        when "list"
+          options[:command] = :list
+          options[:stage] = args[1]
+        when "create"
+          options[:command] = :create
+          options[:stage] = args[1]
+          options[:path] = args[2]
+        else
+          if options[:command].nil?
+            options[:command] = :create # allow 
+            options[:deprecated] = true
+            options[:stage] = args[0]
+            options[:path] = args[1]
+          end
+      end
+
+      options
+    end
+
+    def self.from_file(args)
+      options = {}
+      args.extend(::OptionParser::Arguable)
+      args.options do |opts|
+        common_options(opts, options)
+      end.parse!
+      options
+    end
+
+    private
+
+    def self.common_options(opts, options)
+
+      opts.on("--date-separator SEPARATOR",
+              "Sets the separator of the date part of the ref",
+              "Defaults to ''") do |o|
+        options[:date_separator] = o
+      end
+
+      opts.on("--fetch-refs FETCH_REFS", TrueClass,
+              "Whether or not to fetch tags before creating the tag",
+              "Defaults to true") do |o|
+        options[:fetch_refs] = o
+      end
+
+      opts.on("--push-refs PUSH_REFS", TrueClass,
+              "Whether or not to push tags after creating the tag",
+              "Defaults to true") do |o|
+        options[:push_refs] = o
+      end
+
+      opts.on("--remote REMOTE",
+              "specify the git remote",
+              "Defaults to origin") do |o|
+        options[:remote] = o
+      end
+
+      opts.on("--ref-path REF_PATH",
+              "specify the ref-path",
+              "Defaults to auto_tags") do |o|
+        options[:ref_path] = o
+      end
+
+      opts.on("--stages STAGES",
+              "specify a comma-separated list of stages") do |o|
+        options[:stages] = o
+      end
+
+      opts.on("--offline [OFFLINE]", FalseClass,
+              "Same as --fetch-refs=false and --push-refs=false") do |o|
+        options[:offline] = o
+      end
+
+      opts.on("--dry-run [DRYRUN]", TrueClass,
+              "doesn't execute anything, but logs what it would run") do |o|
+        options[:dry_run] = o.nil? || (o == true)
+      end
+
+      opts.on("--verbose [VERBOSE]", TrueClass,
+              "logs all commands") do |o|
+        options[:verbose] = o
+      end
+
+      opts.on("--refs-to-keep REFS_TO_KEEP",
+              "logs all commands") do |o|
+        options[:refs_to_keep] = (o ? o.to_i : nil)
+      end
+
+      opts.on("--executable EXECUTABLE",
+              "the full path to the git executable",
+              "Defaults to git (and assumes git is your path)",
+              "Example: /usr/local/bin/git") do |o|
+        options[:git] = o
+      end
+    end
+
+  end
+end

data/lib/auto_tagger/recipes.rb

@@ -1,54 +1,94 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "auto_tagger"))
 
 Capistrano::Configuration.instance(:must_exist).load do
-  namespace :release_tagger do
+
+  namespace :auto_tagger do
+
+    def auto_tagger_capistrano_helper
+      AutoTagger::CapistranoHelper.new(variables)
+    end
+
+    def auto_tagger
+      auto_tagger_capistrano_helper.auto_tagger
+    end
+
+    def log_auto_tagger(message)
+      logger.info "AUTO TAGGER: #{message}"
+    end
+
     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.
+      Use -Shead=true to set the branch to master, 
+      -Stag=<tag> or -Sref=<ref> to specify the tag explicitly.
     }
     task :set_branch do
-      if branch_name = AutoTagger::CapistranoHelper.new(variables).branch
-        set :branch, branch_name
-        logger.info "setting branch to #{branch_name}"
+      if ref = auto_tagger_capistrano_helper.ref
+        set :branch, ref
+        log_auto_tagger "setting branch to #{ref}"
       else
-        logger.info "AUTO TAGGER: skipping auto-assignment of branch.  Branch will remain the default.}"
+        log_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 = AutoTagger::CapistranoHelper.new(variables).release_tag_entries
-      entries.each do |entry|
-        logger.info entry
+    desc %Q{Creates a tag using the stage variable}
+    task :create_ref, :roles => :app do
+      if variables[:stage]
+        ref = auto_tagger.create_ref(real_revision)
+        log_auto_tagger "created tag #{ref.name} from #{ref.sha}"
+      else
+        ref = auto_tagger.create_ref
+        log_auto_tagger "created tag #{ref.name}"
       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:"
+    desc %Q{DEPRECATED: Prints the most current tags from all stages}
+    task :print_latest_refs, :roles => :app do
+      log_auto_tagger "release tag history is:"
+      auto_tagger.release_tag_entries.each { |entry| logger.info entry }
+    end
+
+    desc %Q{DEPRECATED: Reads the text file with the latest tag from the shared directory}
+    task :read_ref_from_shared, :roles => :app do
+      log_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
+    desc %Q{DEPRECATED: Writes the tag name to a file in the shared directory}
+    task :write_ref_to_shared, :roles => :app do
       if exists?(:branch)
-        logger.info "AUTO TAGGER: writing tag to shared text file on remote server"
+        log_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"
+        log_auto_tagger "no branch available.  Text file was not written to server"
       end
     end
+  end
+
+  namespace :release_tagger do
+    desc %Q{DEPRECATED: use auto_tagger:set_branch }
+    task :set_branch do
+      auto_tagger.set_branch
+    end
 
-    desc %Q{Creates a tag using the stage variable}
+    desc %Q{DEPRECATED: use auto_tagger:create_ref}
     task :create_tag, :roles => :app do
-      if variables[:stage]
-        tag_name = AutoTagger::Runner.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::Runner.new(:production, variables[:working_directory]).create_tag
-        logger.info "AUTO TAGGER created tag #{tag_name}"
-      end
+      auto_tagger.create_ref
+    end
+
+    desc %Q{DEPRECATED: use auto_tagger:print_latest_tags}
+    task :print_latest_refs, :roles => :app do
+      auto_tagger.print_latest_tags
+    end
+
+    desc %Q{DEPRECATED: use auto_tagger:read_ref_from_shared}
+    task :read_tag_from_shared, :roles => :app do
+      auto_tagger.read_ref_from_shared
+    end
+
+    desc %Q{DEPRECATED: use auto_tagger:write_ref_to_shared}
+    task :write_tag_to_shared, :roles => :app do
+      auto_tagger.write_ref_to_shared
     end
   end
+
 end

data/lib/auto_tagger.rb

@@ -1,9 +1,14 @@
+require 'optparse'
 [
-  'commander',
-  'repository',
-  'tag',
+  'deprecator',
+  'git/ref',
+  'git/ref_set',
+  'git/repo',
   'base',
-  'stage_manager',
+  'command_line',
+  'commander',
+  'configuration',
+  'options',
   'capistrano_helper'
 ].each do |file|
   require File.expand_path(File.join(File.dirname(__FILE__), "auto_tagger", file))