capistrano 1.4.2 → 2.0.0

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

@@ -0,0 +1,44 @@
+require 'capistrano/recipes/deploy/local_dependency'
+require 'capistrano/recipes/deploy/remote_dependency'
+
+module Capistrano
+  module Deploy
+    class Dependencies
+      include Enumerable
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @dependencies = []
+        yield self if block_given?
+      end
+
+      def check
+        yield self
+        self
+      end
+  
+      def remote
+        dep = RemoteDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def local
+        dep = LocalDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def each
+        @dependencies.each { |d| yield d }
+        self
+      end
+
+      def pass?
+        all? { |d| d.pass? }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Capistrano
+  module Deploy
+    class LocalDependency
+      attr_reader :configuration
+      attr_reader :message
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+      end
+
+      def command(command)
+        @message ||= "`#{command}' could not be found in the path on the local host"
+        @success = find_in_path(command)
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+    private
+
+      # Searches the path, looking for the given utility. If an executable
+      # 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) : [""]
+
+        path.each do |dir|
+          suffixes.each do |sfx|
+            file = File.join(dir, utility + sfx)
+            return true if File.executable?(file)
+          end
+        end
+
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Capistrano
+  module Deploy
+    class RemoteDependency
+      attr_reader :configuration
+      attr_reader :hosts
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+      end
+
+      def directory(path, options={})
+        @message ||= "`#{path}' is not a directory"
+        try("test -d #{path}", options)
+        self
+      end
+
+      def writable(path, options={})
+        @message ||= "`#{path}' is not writable"
+        try("test -w #{path}", options)
+        self
+      end
+
+      def command(command, options={})
+        @message ||= "`#{command}' could not be found in the path"
+        try("which #{command}", options)
+        self
+      end
+
+      def gem(name, version, options={})
+        @message ||= "gem `#{name}' #{version} could not be found"
+        gem_cmd = configuration.fetch(:gem_command, "gem")
+        try("#{gem_cmd} specification --version '#{version}' #{name} 2>&1 | awk 'BEGIN { s = 0 } /^name:/ { s = 1; exit }; END { if(s == 0) exit 1 }'", options)
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+      def message
+        s = @message.dup
+        s << " (#{@hosts})" if @hosts && @hosts.any?
+        s
+      end
+
+    private
+
+      def try(command, options)
+        return unless @success # short-circuit evaluation
+        configuration.run(command, options) do |ch,stream,out|
+          warn "#{ch[:server]}: #{out}" if stream == :err
+        end
+      rescue Capistrano::CommandError => e
+        @success = false
+        @hosts = e.hosts.join(', ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Capistrano
+  module Deploy
+    module SCM
+      def self.new(scm, config={})
+        scm_file = "capistrano/recipes/deploy/scm/#{scm}"
+        require(scm_file)
+
+        scm_const = scm.to_s.capitalize.gsub(/_(.)/) { $1.upcase }
+        if const_defined?(scm_const)
+          const_get(scm_const).new(config)
+        else
+          raise Capistrano::Error, "could not find `#{name}::#{scm_const}' in `#{scm_file}'"
+        end
+      rescue LoadError
+        raise Capistrano::Error, "could not find any SCM named `#{scm}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+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
+
+        # 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
+
+        private
+
+          # A helper for accessing variable values, which takes into
+          # consideration the current mode ("normal" vs. "local").
+          def variable(name)
+            if local? && configuration.exists?("local_#{name}".to_sym)
+              return configuration["local_#{name}".to_sym]
+            else
+              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 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
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+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 :branch, 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' 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.
+        def export(revision, destination)
+          [checkout(revision, destination) && "rm -rf #{destination}/.bzr"].join(" && ")
+        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)
+          if revision == head
+            yield(scm(:revno, repository)).chomp
+          else
+            revision
+          end
+        end
+
+        private
+
+          def revswitch(revision)
+            if revision == :head
+              nil
+            else
+              "-r #{revision}"
+            end
+          end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+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}")).
+                       grep(/^date:/).
+                       map { |line| line[/^date: (.*?);/, 1] }.
+                       sort.last
+          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}$/ # 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