capistrano 2.0.0 → 2.15.9

data/lib/capistrano/recipes/compat.rb

@@ -7,7 +7,7 @@ load 'deploy'
 map = { "diff_from_last_deploy"  => "deploy:pending:diff",
         "update"                 => "deploy:update",
         "update_code"            => "deploy:update_code",
-        "symlink"                => "deploy:symlink",
+        "symlink"                => "deploy:create_symlink",
         "restart"                => "deploy:restart",
         "rollback"               => "deploy:rollback",
         "cleanup"                => "deploy:cleanup",
@@ -29,4 +29,4 @@ task :spinner do
   warn "[DEPRECATED] `spinner' is deprecated. Use `deploy:start' instead."
   set :runner, fetch(:spinner_user, "app")
   deploy.start
-end
+end

data/lib/capistrano/recipes/deploy/assets.rb

@@ -0,0 +1,202 @@
+require 'json'
+
+load 'deploy' unless defined?(_cset)
+
+_cset :asset_env, "RAILS_GROUPS=assets"
+_cset :assets_prefix, "assets"
+_cset :shared_assets_prefix, "assets"
+_cset :assets_role, [:web]
+_cset :expire_assets_after, (3600 * 24 * 7)
+_cset(:asset_manifest_prefix) { (`sprockets -v`.chomp < "3.0" ? "manifest" : ".sprockets-manifest") rescue "manifest" }
+
+_cset :normalize_asset_timestamps, false
+
+before 'deploy:finalize_update',   'deploy:assets:symlink'
+after  'deploy:update_code',       'deploy:assets:precompile'
+before 'deploy:assets:precompile', 'deploy:assets:update_asset_mtimes'
+after  'deploy:cleanup',           'deploy:assets:clean_expired'
+after  'deploy:rollback:revision', 'deploy:assets:rollback'
+
+def shared_manifest_path
+  @shared_manifest_path ||= capture("ls #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}*").strip
+end
+
+# Parses manifest and returns array of uncompressed and compressed asset filenames with and without digests
+# "Intelligently" determines format of string - supports YAML and JSON
+def parse_manifest(str)
+  assets_hash = str[0,1] == '{' ? JSON.parse(str)['assets'] : YAML.load(str)
+
+  assets_hash.to_a.flatten.map {|a| [a, "#{a}.gz"] }.flatten
+end
+
+namespace :deploy do
+  namespace :assets do
+    desc <<-DESC
+      [internal] This task will set up a symlink to the shared directory \
+      for the assets directory. Assets are shared across deploys to avoid \
+      mid-deploy mismatches between old application html asking for assets \
+      and getting a 404 file not found error. The assets cache is shared \
+      for efficiency. If you customize the assets path prefix, override the \
+      :assets_prefix variable to match. If you customize shared assets path \
+      prefix, override :shared_assets_prefix variable to match.
+    DESC
+    task :symlink, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        rm -rf #{latest_release}/public/#{assets_prefix} &&
+        mkdir -p #{latest_release}/public &&
+        mkdir -p #{shared_path}/#{shared_assets_prefix} &&
+        ln -s #{shared_path}/#{shared_assets_prefix} #{latest_release}/public/#{assets_prefix}
+      CMD
+    end
+
+    desc <<-DESC
+      Run the asset precompilation rake task. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :precompile, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        cd -- #{latest_release} && 
+        RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} #{rake} assets:precompile
+      CMD
+
+      if capture("ls -1 #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* | wc -l").to_i > 1
+        raise "More than one asset manifest file was found in '#{shared_path.shellescape}/#{shared_assets_prefix}'.  If you are upgrading a Rails 3 application to Rails 4, follow these instructions: http://github.com/capistrano/capistrano/wiki/Upgrading-to-Rails-4#asset-pipeline"
+      end
+
+      # Sync manifest filenames across servers if our manifest has a random filename
+      if shared_manifest_path =~ /#{asset_manifest_prefix}-.+\./
+        run <<-CMD.compact
+          [ -e #{shared_manifest_path.shellescape} ] || mv -- #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* #{shared_manifest_path.shellescape}
+        CMD
+      end
+
+      # Copy manifest to release root (for clean_expired task)
+      run <<-CMD.compact
+        cp -- #{shared_manifest_path.shellescape} #{current_release.to_s.shellescape}/assets_manifest#{File.extname(shared_manifest_path)}
+      CMD
+    end
+
+    desc <<-DESC
+      [internal] Updates the mtimes for assets that are required by the current release.
+      This task runs before assets:precompile.
+    DESC
+    task :update_asset_mtimes, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch assets/manifest contents.
+      manifest_content = capture("[ -e '#{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}*' ] && cat #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* || echo").strip
+
+      if manifest_content != ""
+        current_assets = parse_manifest(manifest_content)
+        logger.info "Updating mtimes for ~#{current_assets.count} assets..."
+        put current_assets.map{|a| "#{shared_path}/#{shared_assets_prefix}/#{a}" }.join("\n"), "#{deploy_to}/TOUCH_ASSETS", :via => :scp
+        run <<-CMD.compact
+          cat #{deploy_to.shellescape}/TOUCH_ASSETS | while read asset; do
+            touch -c -- "$asset";
+          done &&
+          rm -f -- #{deploy_to.shellescape}/TOUCH_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Run the asset clean rake task. Use with caution, this will delete \
+      all of your compiled assets. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :clean, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
+    end
+
+    desc <<-DESC
+      Clean up any assets that haven't been deployed for more than :expire_assets_after seconds.
+      Default time to keep old assets is one week. Set the :expire_assets_after variable
+      to change the assets expiry time. Assets will only be deleted if they are not required by
+      an existing release.
+    DESC
+    task :clean_expired, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch all assets_manifest contents.
+      manifests_output = capture <<-CMD.compact
+        for manifest in #{releases_path.shellescape}/*/assets_manifest.*; do
+          cat -- "$manifest" 2> /dev/null && printf ':::' || true;
+        done
+      CMD
+      manifests = manifests_output.split(':::')
+
+      if manifests.empty?
+        logger.info "No manifests in #{releases_path}/*/assets_manifest.*"
+      else
+        logger.info "Fetched #{manifests.count} manifests from #{releases_path}/*/assets_manifest.*"
+        current_assets = Set.new
+        manifests.each do |content|
+          current_assets += parse_manifest(content)
+        end
+        current_assets += [File.basename(shared_manifest_path), "sources_manifest.yml"]
+
+        # Write the list of required assets to server.
+        logger.info "Writing required assets to #{deploy_to}/REQUIRED_ASSETS..."
+        escaped_assets = current_assets.sort.join("\n").gsub("\"", "\\\"") << "\n"
+        put escaped_assets, "#{deploy_to}/REQUIRED_ASSETS", :via => :scp
+
+        # Finds all files older than X minutes, then removes them if they are not referenced
+        # in REQUIRED_ASSETS.
+        expire_after_mins = (expire_assets_after.to_f / 60.0).to_i
+        logger.info "Removing assets that haven't been deployed for #{expire_after_mins} minutes..."
+        # LC_COLLATE=C tells the `sort` and `comm` commands to sort files in byte order.
+        run <<-CMD.compact
+          cd -- #{deploy_to.shellescape}/ &&
+          LC_COLLATE=C sort REQUIRED_ASSETS -o REQUIRED_ASSETS &&
+          cd -- #{shared_path.shellescape}/#{shared_assets_prefix}/ &&
+          for f in $(
+            find * -mmin +#{expire_after_mins.to_s.shellescape} -type f | LC_COLLATE=C sort |
+            LC_COLLATE=C comm -23 -- - #{deploy_to.shellescape}/REQUIRED_ASSETS
+          ); do
+            echo "Removing unneeded asset: $f";
+            rm -f -- "$f";
+          done;
+          rm -f -- #{deploy_to.shellescape}/REQUIRED_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Rolls back assets to the previous release by symlinking the release's manifest
+      to shared/assets/manifest, and finally recompiling or regenerating nondigest assets.
+    DESC
+    task :rollback, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      previous_manifest = capture("ls #{previous_release.shellescape}/assets_manifest.*").strip
+      if capture("[ -e #{previous_manifest.shellescape} ] && echo true || echo false").strip != 'true'
+        puts "#{previous_manifest} is missing! Cannot roll back assets. " <<
+             "Please run deploy:assets:precompile to update your assets when the rollback is finished."
+      else
+        # If the user is rolling back a Rails 4 app to Rails 3
+        if File.extname(previous_manifest) == '.yml' && File.extname(shared_manifest_path) == '.json'
+          # Remove the existing JSON manifest
+          run "rm -f -- #{shared_manifest_path.shellescape}"
+
+          # Restore the manifest to the Rails 3 path
+          restored_manifest_path = "#{shared_path.shellescape}/#{shared_assets_prefix}/manifest.yml"
+        else
+          # If the user is not rolling back from Rails 4 to 3, we just want to replace the current manifest
+          restored_manifest_path = shared_manifest_path
+        end
+
+        run <<-CMD.compact
+          cd -- #{previous_release.shellescape} &&
+          cp -f -- #{previous_manifest.shellescape} #{restored_manifest_path.shellescape} &&
+          [ -z "$(#{rake} -P | grep assets:precompile:nondigest)" ] || #{rake} RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} assets:precompile:nondigest
+        CMD
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/dependencies.rb

@@ -18,7 +18,7 @@ module Capistrano
         yield self
         self
       end
-  
+
       def remote
         dep = RemoteDependency.new(configuration)
         @dependencies << dep
@@ -41,4 +41,4 @@ module Capistrano
       end
     end
   end
-end
+end

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -30,7 +30,7 @@ module Capistrano
       # file is found that matches the parameter, this returns true.
       def find_in_path(utility)
         path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
-        suffixes = RUBY_PLATFORM =~ /mswin/ ? %w(.bat .exe .com .cmd) : [""]
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
 
         path.each do |dir|
           suffixes.each do |sfx|
@@ -41,6 +41,14 @@ module Capistrano
 
         false
       end
+
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
+      end
     end
   end
-end
+end

data/lib/capistrano/recipes/deploy/remote_dependency.rb

@@ -1,3 +1,5 @@
+require 'capistrano/errors'
+
 module Capistrano
   module Deploy
     class RemoteDependency
@@ -7,6 +9,7 @@ module Capistrano
       def initialize(configuration)
         @configuration = configuration
         @success = true
+        @hosts = nil
       end
 
       def directory(path, options={})
@@ -15,6 +18,12 @@ module Capistrano
         self
       end
 
+      def file(path, options={})
+        @message ||= "`#{path}' is not a file"
+        try("test -f #{path}", options)
+        self
+      end
+
       def writable(path, options={})
         @message ||= "`#{path}' is not writable"
         try("test -w #{path}", options)
@@ -34,6 +43,48 @@ module Capistrano
         self
       end
 
+      def deb(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("dpkg -s #{name} | grep '^Version: #{version}'", options)
+        self
+      end
+
+      def rpm(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("rpm -q #{name} | grep '#{version}'", options)
+        self
+      end
+
+      def match(command, expect, options={})
+        expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+
+        output_per_server = {}
+        try("#{command} ", options) do |ch, stream, out|
+          output_per_server[ch[:server]] ||= ''
+          output_per_server[ch[:server]] += out
+        end
+
+        # It is possible for some of these commands to return a status != 0
+        # (for example, rake --version exits with a 1). For this check we
+        # just care if the output matches, so we reset the success flag.
+        @success = true
+
+        errored_hosts = []
+        output_per_server.each_pair do |server, output|
+          next if output =~ expect
+          errored_hosts << server
+        end
+
+        if errored_hosts.any?
+          @hosts = errored_hosts.join(', ')
+          output = output_per_server[errored_hosts.first]
+          @message = "the output #{output.inspect} from #{command.inspect} did not match #{expect.inspect}"
+          @success = false
+        end
+
+        self
+      end
+
       def or(message)
         @message = message
         self
@@ -45,7 +96,7 @@ module Capistrano
 
       def message
         s = @message.dup
-        s << " (#{@hosts})" if @hosts && @hosts.any?
+        s << " (#{@hosts})" if @hosts
         s
       end
 
@@ -53,8 +104,9 @@ module Capistrano
 
       def try(command, options)
         return unless @success # short-circuit evaluation
-        configuration.run(command, options) do |ch,stream,out|
+        configuration.invoke_command(command, options) do |ch,stream,out|
           warn "#{ch[:server]}: #{out}" if stream == :err
+          yield ch, stream, out if block_given?
         end
       rescue Capistrano::CommandError => e
         @success = false

data/lib/capistrano/recipes/deploy/scm/accurev.rb

@@ -0,0 +1,169 @@
+require 'capistrano/recipes/deploy/scm/base'
+require 'rexml/xpath'
+require 'rexml/document'
+
+module Capistrano
+  module Deploy
+    module SCM
+      # Accurev bridge for use by Capistrano. This implementation does not
+      # implement all features of a Capistrano SCM module. The ones that are
+      # left out are either exceedingly difficult to implement with Accurev
+      # or are considered bad form.
+      #
+      # When using this module in a project, the following variables are used:
+      #  * :repository - This should match the depot that code lives in. If your code
+      #                  exists in a subdirectory, you can append the path depot.
+      #                  eg. foo-depot/bar_dir
+      #  * :stream - The stream in the depot that code should be pulled from. If
+      #              left blank, the depot stream will be used
+      #  * :revision - Should be in the form 'stream/transaction'.
+      class Accurev < Base
+        include REXML
+        default_command 'accurev'
+
+        # Defines pseudo-revision value for the most recent changes to be deployed.
+        def head
+          "#{stream}/highest"
+        end
+
+        # Given an Accurev revision identifier, this method returns an identifier that
+        # can be used for later SCM calls. This returned identifier will not
+        # change as a result of further SCM activity.
+        def query_revision(revision)
+          internal_revision = InternalRevision.parse(revision)
+          return revision unless internal_revision.psuedo_revision?
+
+          logger.debug("Querying for real revision for #{internal_revision}")
+          rev_stream = internal_revision.stream
+
+          logger.debug("Determining what type of stream #{rev_stream} is...")
+          stream_xml = yield show_streams_for(rev_stream)
+          stream_doc = Document.new(stream_xml)
+          type = XPath.first(stream_doc, '//streams/stream/@type').value
+
+          case type
+          when 'snapshot'
+            InternalRevision.new(rev_stream, 'highest').to_s
+          else
+            logger.debug("Getting latest transaction id in #{rev_stream}")
+            # Doing another yield for a second Accurev call. Hopefully this is ok.
+            hist_xml = yield scm(:hist, '-ftx', '-s', rev_stream, '-t', 'now.1')
+            hist_doc = Document.new(hist_xml)
+            transaction_id = XPath.first(hist_doc, '//AcResponse/transaction/@id').value
+            InternalRevision.new(stream, transaction_id).to_s
+          end
+        end
+
+        # Pops a copy of the code for the specified Accurev revision identifier.
+        # The revision identifier is represented as a stream & transaction ID combo.
+        # Accurev can only pop a particular transaction if a stream is created on the server
+        # with a time basis of that transaction id. Therefore, we will create a stream with
+        # the required criteria and pop that.
+        def export(revision_id, destination)
+          revision = InternalRevision.parse(revision_id)
+          logger.debug("Exporting #{revision.stream}/#{revision.transaction_id} to #{destination}")
+
+          commands = [
+            change_or_create_stream("#{revision.stream}-capistrano-deploy", revision),
+            "mkdir -p #{destination}",
+            scm_quiet(:pop, "-Rv #{stream}", "-L #{destination}", "'/./#{subdir}'")
+          ]
+          if subdir
+            commands.push(
+              "mv #{destination}/#{subdir}/* #{destination}",
+              "rm -rf #{File.join(destination, subdir)}"
+            )
+          end
+          commands.join(' && ')
+        end
+
+        # Returns the command needed to show the changes that exist between the two revisions.
+        def log(from, to=head)
+          logger.info("Getting transactions between #{from} and #{to}")
+          from_rev = InternalRevision.parse(from)
+          to_rev = InternalRevision.parse(to)
+
+          [
+            scm(:hist, '-s', from_rev.stream, '-t', "#{to_rev.transaction_id}-#{from_rev.transaction_id}"),
+            "sed -e '/transaction #{from_rev.transaction_id}/ { Q }'"
+          ].join(' | ')
+        end
+
+        # Returns the command needed to show the diff between what is deployed and what is
+        # pending. Because Accurev can not do this task without creating some streams,
+        # two time basis streams will be created for the purposes of doing the diff.
+        def diff(from, to=head)
+          from = InternalRevision.parse(from)
+          to = InternalRevision.parse(to)
+
+          from_stream = "#{from.stream}-capistrano-diff-from"
+          to_stream = "#{to.stream}-capistrano-diff-to"
+
+          [
+            change_or_create_stream(from_stream, from),
+            change_or_create_stream(to_stream, to),
+            scm(:diff, '-v', from_stream, '-V', to_stream, '-a')
+          ].join(' && ')
+        end
+
+        private
+        def depot
+          repository.split('/')[0]
+        end
+
+        def stream
+          variable(:stream) || depot
+        end
+
+        def subdir
+          repository.split('/')[1..-1].join('/') unless repository.index('/').nil?
+        end
+
+        def change_or_create_stream(name, revision)
+          [
+            scm_quiet(:mkstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id),
+            scm_quiet(:chstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id)
+          ].join('; ')
+        end
+
+        def show_streams_for(stream)
+          scm :show, '-fx', '-s', stream, :streams
+        end
+
+        def scm_quiet(*args)
+          scm(*args) + (variable(:scm_verbose) ? '' : '&> /dev/null')
+        end
+
+        class InternalRevision
+          attr_reader :stream, :transaction_id
+
+          def self.parse(string)
+            match = /([^\/]+)(\/(.+)){0,1}/.match(string)
+            raise "Unrecognized revision identifier: #{string}" unless match
+
+            stream = match[1]
+            transaction_id = match[3] || 'highest'
+            InternalRevision.new(stream, transaction_id)
+          end
+
+          def initialize(stream, transaction_id)
+            @stream = stream
+            @transaction_id = transaction_id
+          end
+
+          def psuedo_revision?
+            @transaction_id == 'highest'
+          end
+
+          def to_s
+            "#{stream}/#{transaction_id}"
+          end
+
+          def ==(other)
+            (stream == other.stream) && (transaction_id == other.transaction_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/scm/base.rb

@@ -54,7 +54,7 @@ module Capistrano
         # and "local_scm_command" to be set, if the two differ.
         #
         # Alternatively, it may be called with a block, and for the duration of
-        # the block, all requests on this configuration object will be 
+        # the block, all requests on this configuration object will be
         # considered local.
         def local
           if block_given?
@@ -114,6 +114,18 @@ module Capistrano
           raise NotImplementedError, "`query_revision' is not implemented by #{self.class.name}"
         end
 
+        # Returns the revision number immediately following revision, if at
+        # all possible. A block should always be passed to this method, which
+        # accepts a command to invoke and returns the result, although a
+        # particular SCM's implementation is not required to invoke the block.
+        #
+        # By default, this method simply returns the revision itself. If a
+        # particular SCM is able to determine a subsequent revision given a
+        # revision identifier, it should override this method.
+        def next_revision(revision)
+          revision
+        end
+
         # Should analyze the given text and determine whether or not a
         # response is expected, and if so, return the appropriate response.
         # If no response is expected, return nil. The +state+ parameter is a
@@ -138,15 +150,22 @@ module Capistrano
           command || default_command
         end
 
+        # A helper method that can be used to define SCM commands naturally.
+        # It returns a single string with all arguments joined by spaces,
+        # with the scm command prefixed onto it.
+        def scm(*args)
+          [command, *args].compact.join(" ")
+        end
+
         private
 
           # A helper for accessing variable values, which takes into
           # consideration the current mode ("normal" vs. "local").
-          def variable(name)
+          def variable(name, default = nil)
             if local? && configuration.exists?("local_#{name}".to_sym)
-              return configuration["local_#{name}".to_sym]
+              return configuration["local_#{name}".to_sym].nil? ? default : configuration["local_#{name}".to_sym]
             else
-              configuration[name]
+              configuration[name].nil? ? default : configuration[name]
             end
           end
 
@@ -162,17 +181,18 @@ module Capistrano
             self.class.default_command
           end
 
-          # A helper method that can be used to define SCM commands naturally.
-          # It returns a single string with all arguments joined by spaces,
-          # with the scm command prefixed onto it.
-          def scm(*args)
-            [command, *args].compact.join(" ")
-          end
-
           # A convenience method for accessing the declared repository value.
           def repository
             variable(:repository)
           end
+
+          def arguments(command = :all)
+            value = variable(:scm_arguments)
+            if value.is_a?(Hash)
+              value = value[command]
+            end
+            value
+          end
       end
 
     end

data/lib/capistrano/recipes/deploy/scm/bzr.rb

@@ -21,7 +21,7 @@ module Capistrano
         # Returns the command that will check out the given revision to the
         # given destination.
         def checkout(revision, destination)
-          scm :branch, revswitch(revision), repository, destination
+          scm :checkout, "--lightweight", revswitch(revision), repository, destination
         end
 
         # The bzr 'update' command does not support updating to a specific
@@ -33,13 +33,9 @@ module Capistrano
           commands.join(" && ")
         end
 
-        # The bzr 'export' command would work fine, except it doesn't let you
-        # specify the repository itself, so it only works if there is a working
-        # tree handy, locally. Since this needs to work even on a remote host
-        # where there is no working tree, we'll just do a checkout, followed
-        # by a deletion of the ".bzr" metadata directory.
+        # The bzr 'export' does an export similar to other SCM systems
         def export(revision, destination)
-          [checkout(revision, destination) && "rm -rf #{destination}/.bzr"].join(" && ")
+          scm :export, revswitch(revision), destination, repository
         end
 
         # The bzr "diff" command doesn't accept a repository argument, so it
@@ -63,20 +59,24 @@ module Capistrano
         # If the 'revision' argument, on the other hand, is not :head, it is
         # simply returned.
         def query_revision(revision)
-          if revision == head
-            yield(scm(:revno, repository)).chomp
-          else
-            revision
-          end
+          return revision unless :head == revision
+
+          command = scm('revno', repository)
+          result = yield(command)
+        end
+
+        # Increments the given revision number and returns it.
+        def next_revision(revision)
+          revision.to_i + 1
         end
 
         private
 
           def revswitch(revision)
-            if revision == :head
+            if revision == :head || revision.nil?
               nil
             else
-              "-r #{revision}"
+              "-r #{revision}".chomp
             end
           end
       end