capistrano 2.15.11 → 3.0.0.pre

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

@@ -1,169 +0,0 @@
-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

@@ -1,200 +0,0 @@
-module Capistrano
-  module Deploy
-    module SCM
-
-      # The ancestor class for all Capistrano SCM implementations. It provides
-      # minimal infrastructure for subclasses to build upon and override.
-      #
-      # Note that subclasses that implement this abstract class only return
-      # the commands that need to be executed--they do not execute the commands
-      # themselves. In this way, the deployment method may execute the commands
-      # either locally or remotely, as necessary.
-      class Base
-        class << self
-          # If no parameters are given, it returns the current configured
-          # name of the command-line utility of this SCM. If a parameter is
-          # given, the defeault command is set to that value.
-          def default_command(value=nil)
-            if value
-              @default_command = value
-            else
-              @default_command
-            end
-          end
-        end
-
-        # Wraps an SCM instance and forces all messages sent to it to be
-        # relayed to the underlying SCM instance, in "local" mode. See
-        # Base#local.
-        class LocalProxy
-          def initialize(scm)
-            @scm = scm
-          end
-
-          def method_missing(sym, *args, &block)
-            @scm.local { return @scm.send(sym, *args, &block) }
-          end
-        end
-
-        # The options available for this SCM instance to reference. Should be
-        # treated like a hash.
-        attr_reader :configuration
-
-        # Creates a new SCM instance with the given configuration options.
-        def initialize(configuration={})
-          @configuration = configuration
-        end
-
-        # Returns a proxy that wraps the SCM instance and forces it to operate
-        # in "local" mode, which changes how variables are looked up in the
-        # configuration. Normally, if the value of a variable "foo" is needed,
-        # it is queried for in the configuration as "foo". However, in "local"
-        # mode, first "local_foo" would be looked for, and only if it is not
-        # found would "foo" be used. This allows for both (e.g.) "scm_command"
-        # 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
-        # considered local.
-        def local
-          if block_given?
-            begin
-              saved, @local_mode = @local_mode, true
-              yield
-            ensure
-              @local_mode = saved
-            end
-          else
-            LocalProxy.new(self)
-          end
-        end
-
-        # Returns true if running in "local" mode. See #local.
-        def local?
-          @local_mode
-        end
-
-        # Returns the string used to identify the latest revision in the
-        # repository. This will be passed as the "revision" parameter of
-        # the methods below.
-        def head
-          raise NotImplementedError, "`head' is not implemented by #{self.class.name}"
-        end
-
-        # Checkout a copy of the repository, at the given +revision+, to the
-        # given +destination+. The checkout is suitable for doing development
-        # work in, e.g. allowing subsequent commits and updates.
-        def checkout(revision, destination)
-          raise NotImplementedError, "`checkout' is not implemented by #{self.class.name}"
-        end
-
-        # Resynchronize the working copy in +destination+ to the specified
-        # +revision+.
-        def sync(revision, destination)
-          raise NotImplementedError, "`sync' is not implemented by #{self.class.name}"
-        end
-
-        # Compute the difference between the two revisions, +from+ and +to+.
-        def diff(from, to=nil)
-          raise NotImplementedError, "`diff' is not implemented by #{self.class.name}"
-        end
-
-        # Return a log of all changes between the two specified revisions,
-        # +from+ and +to+, inclusive.
-        def log(from, to=nil)
-          raise NotImplementedError, "`log' is not implemented by #{self.class.name}"
-        end
-
-        # If the given revision represents a "real" revision, this should
-        # simply return the revision value. If it represends a pseudo-revision
-        # (like Subversions "HEAD" identifier), it should yield a string
-        # containing the commands that, when executed will return a string
-        # that this method can then extract the real revision from.
-        def query_revision(revision)
-          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
-        # hash that may be used to preserve state between calls. This method
-        # is used to define how Capistrano should respond to common prompts
-        # and messages from the SCM, like password prompts and such. By
-        # default, the output is simply displayed.
-        def handle_data(state, stream, text)
-          logger.info "[#{stream}] #{text}"
-          nil
-        end
-
-        # Returns the name of the command-line utility for this SCM. It first
-        # looks at the :scm_command variable, and if it does not exist, it
-        # then falls back to whatever was defined by +default_command+.
-        #
-        # If scm_command is set to :default, the default_command will be
-        # returned.
-        def command
-          command = variable(:scm_command)
-          command = nil if command == :default
-          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, default = nil)
-            if local? && configuration.exists?("local_#{name}".to_sym)
-              return configuration["local_#{name}".to_sym].nil? ? default : configuration["local_#{name}".to_sym]
-            else
-              configuration[name].nil? ? default : configuration[name]
-            end
-          end
-
-          # A reference to a Logger instance that the SCM can use to log
-          # activity.
-          def logger
-            @logger ||= variable(:logger) || Capistrano::Logger.new(:output => STDOUT)
-          end
-
-          # A helper for accessing the default command name for this SCM. It
-          # simply delegates to the class' +default_command+ method.
-          def default_command
-            self.class.default_command
-          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
-  end
-end

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

@@ -1,86 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the Bazaar-NG revision
-      # control system (http://bazaar-vcs.org/).
-      class Bzr < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "bzr"
-
-        # Bazaar-NG doesn't support any pseudo-id's, so we'll use the convention
-        # in this adapter that the :head symbol means the most recently
-        # committed revision.
-        def head
-          :head
-        end
-
-        # Returns the command that will check out the given revision to the
-        # given destination.
-        def checkout(revision, destination)
-          scm :checkout, "--lightweight", revswitch(revision), repository, destination
-        end
-
-        # The bzr 'update' command does not support updating to a specific
-        # revision, so this just does update, followed by revert (unless
-        # updating to head).
-        def sync(revision, destination)
-          commands = [scm(:update, destination)]
-          commands << [scm(:revert, revswitch(revision), destination)] if revision != head
-          commands.join(" && ")
-        end
-
-        # The bzr 'export' does an export similar to other SCM systems
-        def export(revision, destination)
-          scm :export, revswitch(revision), destination, repository
-        end
-
-        # The bzr "diff" command doesn't accept a repository argument, so it
-        # must be run from within a working tree.
-        def diff(from, to=nil)
-          switch = "-r#{from}"
-          switch << "..#{to}" if to
-
-          scm :diff, switch
-        end
-
-        # Returns a log of changes between the two revisions (inclusive).
-        def log(from, to=nil)
-          scm :log, "--short", "-r#{from}..#{to}", repository
-        end
-
-        # Attempts to translate the given revision identifier to a "real"
-        # revision. If the identifier is :head, the "bzr revno" command will
-        # be yielded, and the block must execute the command and return the
-        # output. The revision will be extracted from the output and returned.
-        # If the 'revision' argument, on the other hand, is not :head, it is
-        # simply returned.
-        def query_revision(revision)
-          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 || revision.nil?
-              nil
-            else
-              "-r #{revision}".chomp
-            end
-          end
-      end
-
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the CVS revision
-      # control system.
-      class Cvs < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "cvs"
-
-        # CVS understands 'HEAD' to refer to the latest revision in the
-        # repository.
-        def head
-          "HEAD"
-        end
-
-        # Returns the command that will check out the given revision to the
-        # given destination.
-        def checkout(revision, destination)
-          [ prep_destination(destination),
-            scm(verbose, cvs_root, :checkout, cvs_revision(revision), cvs_destination(destination), variable(:scm_module))
-          ].join(' && ')
-        end
-
-        # Returns the command that will do an "cvs update" to the given
-        # revision, for the working copy at the given destination.
-        def sync(revision, destination)
-          [ prep_destination(destination),
-            scm(verbose, cvs_root, :update, cvs_revision(revision), cvs_destination(destination))
-          ].join(' && ')
-        end
-
-        # Returns the command that will do an "cvs export" of the given revision
-        # to the given destination.
-        def export(revision, destination)
-          [ prep_destination(destination),
-            scm(verbose, cvs_root, :export, cvs_revision(revision), cvs_destination(destination), variable(:scm_module))
-          ].join(' && ')
-        end
-
-        # Returns the command that will do an "cvs diff" for the two revisions.
-        def diff(from, to=nil)
-          rev_type = revision_type(from)
-          if rev_type == :date
-            range_args = "-D '#{from}' -D '#{to || 'now'}'"
-          else
-            range_args = "-r '#{from}' -r '#{to || head}'"
-          end
-          scm cvs_root, :diff, range_args
-        end
-
-        # Returns an "cvs log" command for the two revisions.
-        def log(from, to=nil)
-          rev_type = revision_type(from)
-          if rev_type == :date
-            range_arg = "-d '#{from}<#{to || 'now'}'"
-          else
-            range_arg = "-r '#{from}:#{to || head}'"
-          end
-          scm cvs_root, :log, range_arg
-        end
-
-        # Unfortunately, cvs doesn't support the concept of a revision number like
-        # subversion and other SCM's do.  For now, we'll rely on getting the timestamp
-        # of the latest checkin under the revision that's passed to us.
-        def query_revision(revision)
-          return revision if revision_type(revision) == :date
-          revision = yield(scm(cvs_root, :log, "-r#{revision}")).
-                       split("\n").
-                       select { |line| line =~ /^date:/ }.
-                       map { |line| line[/^date: (.*?);/, 1] }.
-                       sort.last + " UTC"
-          return revision
-        end
-
-        # Determines what the response should be for a particular bit of text
-        # from the SCM. Password prompts, connection requests, passphrases,
-        # etc. are handled here.
-        def handle_data(state, stream, text)
-          logger.info "[#{stream}] #{text}"
-          case text
-          when /\bpassword.*:/i
-            # prompting for a password
-            %("#{variable(:scm_password) || variable(:password)}"\n)
-          when %r{\(yes/no\)}
-            # let's be agreeable...
-            "yes\n"
-          end
-        end
-
-        private
-
-          # Constructs the CVSROOT command-line option
-          def cvs_root
-            root = ""
-            root << "-d #{repository} " if repository
-            root
-          end
-
-          # Constructs the destination dir command-line option
-          def cvs_destination(destination)
-            dest = ""
-            if destination
-              dest_parts = destination.split(/\//);
-              dest << "-d #{dest_parts.pop}"
-            end
-            dest
-          end
-
-          # attempts to guess what type of revision we're working with
-          def revision_type(rev)
-            return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2} UTC$/ # i.e 2007-05-15 08:13:25 UTC
-            return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2}$/ # i.e 2007-05-15 08:13:25
-            return :revision if rev =~ /^\d/ # i.e. 1.2.1
-            return :tag # i.e. RELEASE_1_2
-          end
-
-          # constructs the appropriate command-line switch for specifying a
-          # "revision" in CVS.  This could be a tag, branch, revision (i.e. 1.3)
-          # or a date (to be used with -d)
-          def cvs_revision(rev)
-            revision = ""
-            revision << case revision_type(rev)
-              when :date
-                "-D \"#{rev}\"" if revision_type(rev) == :date
-              when :revision
-                "-r #{rev}"
-              else
-                "-r #{head}"
-            end
-            return revision
-          end
-
-          # If verbose output is requested, return nil, otherwise return the
-          # command-line switch for "quiet" ("-Q").
-          def verbose
-            variable(:scm_verbose) ? nil : "-Q"
-          end
-
-          def prep_destination(destination)
-            dest_parts = destination.split(/\//);
-            checkout_dir = dest_parts.pop
-            dest = dest_parts.join('/')
-            "mkdir -p #{ dest } && cd #{ dest }"
-          end
-      end
-
-    end
-  end
-end