capistrano 2.1.0 → 3.0.0

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

@@ -1,191 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # An SCM module for using Git as your source control tool with Capistrano
-      # 2.0.  If you are using Capistrano 1.x, use this plugin instead:
-      #
-      #   http://scie.nti.st/2007/3/16/capistrano-with-git-shared-repository
-      #
-      # Assumes you are using a shared Git repository.
-      #
-      # Parts of this plugin borrowed from Scott Chacon's version, which I
-      # found on the Capistrano mailing list but failed to be able to get
-      # working.
-      #
-      # FEATURES:
-      #
-      #   * Very simple, only requiring 2 lines in your deploy.rb.
-      #   * Can deploy different branches, tags, or any SHA1 easily.
-      #   * Supports prompting for password / passphrase upon checkout.
-      #     (I am amazed at how some plugins don't do this)
-      #   * Supports :scm_command, :scm_password, :scm_passphrase Capistrano
-      #     directives.
-      #
-      # REQUIREMENTS
-      # ------------
-      #
-      # Git is required to be installed on your remote machine(s), because a
-      # clone and checkout is done to get the code up there.  This is the way
-      # I prefer to deploy; there is no alternative to this, so :deploy_via
-      # is ignored.
-      #
-      # CONFIGURATION
-      # -------------
-      #
-      # Use this plugin by adding the following line in your config/deploy.rb:
-      #
-      #   set :scm, :git
-      #
-      # Set <tt>:repository</tt> to the path of your Git repo:
-      #
-      #   set :repository, "someuser@somehost:/home/myproject"
-      #
-      # The above two options are required to be set, the ones below are
-      # optional.
-      #
-      # You may set <tt>:branch</tt>, which is the reference to the branch, tag,
-      # or any SHA1 you are deploying, for example:
-      #
-      #   set :branch, "origin/master"
-      #
-      # Otherwise, HEAD is assumed.  I strongly suggest you set this.  HEAD is
-      # not always the best assumption.
-      #
-      # The <tt>:scm_command</tt> configuration variable, if specified, will
-      # be used as the full path to the git executable on the *remote* machine:
-      #
-      #   set :scm_command, "/opt/local/bin/git"
-      #
-      # For compatibility with deploy scripts that may have used the 1.x
-      # version of this plugin before upgrading, <tt>:git</tt> is still
-      # recognized as an alias for :scm_command.
-      #
-      # Set <tt>:scm_password</tt> to the password needed to clone your repo
-      # if you don't have password-less (public key) entry:
-      #
-      #   set :scm_password, "my_secret'
-      #
-      # Otherwise, you will be prompted for a password.
-      #
-      # <tt>:scm_passphrase</tt> is also supported.
-      #
-      # The remote cache strategy is also supported.
-      #
-      #   set :repository_cache, "git_master"
-      #   set :deploy_via, :remote_cache
-      #
-      # For faster clone, you can also use shallow cloning.  This will set the
-      # '--depth' flag using the depth specified.  This *cannot* be used 
-      # together with the :remote_cache strategy
-      #
-      #   set :git_shallow_clone, 1
-      #
-      # AUTHORS
-      # -------
-      #
-      # Garry Dolley http://scie.nti.st
-      # Contributions by Geoffrey Grosenbach http://topfunky.com
-      #              and Scott Chacon http://jointheconversation.org
-      
-      class Git < Base
-        # Sets the default command name for this SCM on your *local* machine.
-        # Users may override this by setting the :scm_command variable.
-        default_command "git"
-
-        # When referencing "head", use the branch we want to deploy or, by
-        # default, Git's reference of HEAD (the latest changeset in the default
-        # branch, usually called "master").
-        def head
-          configuration[:branch] || 'HEAD'
-        end
-
-        # Performs a clone on the remote machine, then checkout on the branch
-        # you want to deploy.
-        def checkout(revision, destination)
-          git      = command
-
-          branch   = head
-
-          fail "No branch specified, use for example 'set :branch, \"origin/master\"' in your deploy.rb" unless branch
-
-          if depth = configuration[:git_shallow_clone]
-            execute  = "#{git} clone --depth #{depth} #{configuration[:repository]} #{destination} && "
-          else
-            execute  = "#{git} clone #{configuration[:repository]} #{destination} && "
-          end
-
-          execute += "cd #{destination} && #{git} checkout -b deploy #{branch}" 
-
-          execute
-        end
-
-        # Merges the changes to 'head' since the last fetch, for remote_cache
-        # deployment strategy
-        def sync(revision, destination)
-          execute = "cd #{destination} && git fetch origin && "
-
-          if head == 'HEAD'
-            execute += "git merge origin/HEAD"
-          else
-            execute += "git merge #{head}"
-          end
-
-          execute
-        end
-
-        # Returns a string of diffs between two revisions
-        def diff(from, to=nil)
-          from << "..#{to}" if to
-          scm :diff, from
-        end
-
-        # Returns a log of changes between the two revisions (inclusive).
-        def log(from, to=nil)
-          from << "..#{to}" if to
-          scm :log, from
-        end
-
-        # Getting the actual commit id, in case we were passed a tag
-        # or partial sha or something - it will return the sha if you pass a sha, too
-        def query_revision(revision)
-          yield(scm('rev-parse', revision)).chomp
-        end
-
-        def command
-          # For backwards compatibility with 1.x version of this module
-          configuration[:git] || super
-        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
-            # git is prompting for a password
-            unless pass = configuration[:scm_password]
-              pass = Capistrano::CLI.password_prompt
-            end
-            "#{pass}\n"
-          when %r{\(yes/no\)}
-            # git is asking whether or not to connect
-            "yes\n"
-          when /passphrase/i
-            # git is asking for the passphrase for the user's key
-            unless pass = configuration[:scm_passphrase]
-              pass = Capistrano::CLI.password_prompt
-            end
-            "#{pass}\n"
-          when /accept \(t\)emporarily/
-            # git is asking whether to accept the certificate
-            "t\n"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# Copyright 2007 Matthew Elder <sseses@gmail.com>
-# based on work by Tobias Luetke
-
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the Mercurial revision
-      # control system (http://www.selenic.com/mercurial/).
-      # Latest updates at http://tackletechnology.org/oss/cap2-mercurial
-      class Mercurial < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "hg"
-
-        # For mercurial HEAD == tip except that it bases this assumption on what
-        # tip is in the current repository (so push before you deploy)
-        def head
-          "tip"
-        end
-
-        # Clone the repository and update to the specified changeset.
-        def checkout(changeset, destination)
-          clone(destination) + " && " + update(changeset, destination)
-        end
-
-        # Pull from the repository and update to the specified changeset.
-        def sync(changeset, destination)
-          pull(destination) + " && " + update(changeset, destination)
-        end
-
-        # One day we will have hg archive, although i think its not needed
-        def export(revision, destination)
-          raise NotImplementedError, "`diff' is not implemented by #{self.class.name}" +
-          "use checkout strategy"
-        end
-
-        # Compute the difference between the two changesets +from+ and +to+
-        # as a unified diff.
-        def diff(from, to=nil)
-          scm :diff,
-              "--rev #{from}",
-              (to ? "--rev #{to}" : nil)
-        end
-
-        # Return a log of all changes between the two specified changesets,
-        # +from+ and +to+, inclusive or the log for +from+ if +to+ is omitted.
-        def log(from, to=nil)
-          scm :log,
-              verbose,
-              "--rev #{from}" +
-              (to ? ":#{to}" : "")
-        end
-
-        # Translates a tag to a changeset if needed or just returns changeset.
-        def query_revision(changeset)
-          cmd = scm :log,
-                    verbose,
-                    "-r #{changeset}",
-                    "--template '{node|short}'"
-                    yield cmd
-        end
-
-        # Determine response for SCM prompts
-        # user/pass can come from ssh and http distribution methods
-        # yes/no is for when ssh asks you about fingerprints
-        def handle_data(state, stream, text)
-          logger.info "[#{stream}] #{text}"
-          case text
-          when /^user:/mi
-            if variable(:scm_user)
-              "#{variable(:scm_user)}\n"
-            else
-              raise "No variable :scm_user specified and Mercurial asked!\n" +
-                "Prompt was: #{text}"
-            end
-          when /^password:/mi
-            if variable(:scm_password)
-              "#{variable(:scm_password)}\n"
-            else
-              raise "No variable :scm_password specified and Mercurial asked!\n" +
-                "Prompt was: #{text}"
-            end
-          when /yes\/no/i
-            "yes\n"
-          end
-        end
-
-        private
-
-        # Fine grained mercurial commands
-        def clone(destination) 
-          scm :clone,
-              verbose,
-              "--noupdate", # do not update to tip when cloning is done
-              repository,   # clone which repository?
-              destination   # and put the clone where?
-        end
-
-        def pull(destination)
-          scm :pull,
-              verbose,
-              "--repository #{destination}", # pull changes into what?
-              repository                     # and pull the changes from?
-        end
-
-        def update(changeset, destination)
-          scm :update,
-              verbose,
-              "--repository #{destination}", # update what?
-              "--clean",                     # ignore untracked changes
-              changeset                      # update to this changeset
-        end
-
-        # verbosity configuration grokking :)
-        def verbose
-          case variable(:scm_verbose)
-            when nil:   nil
-            when false: "--quiet"
-            else        "--verbose"
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-# Notes: 
-#  no global verbose flag for scm_verbose
-#  sync, checkout and export are just sync in p4
-#  
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the Perforce revision
-      # control system (http://www.perforce.com).
-      class Perforce < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "p4"
-
-        # Perforce understands '#head' to refer to the latest revision in the
-        # depot.
-        def head
-          'head'
-        end
-
-        # Returns the command that will sync the given revision to the given
-        # destination directory. The perforce client has a fixed destination so
-        # the files must be copied from there to their intended resting place.
-        def checkout(revision, destination)
-          p4_sync(revision, destination, "-f")
-        end
-        
-        # Returns the command that will sync the given revision to the given
-        # destination directory. The perforce client has a fixed destination so
-        # the files must be copied from there to their intended resting place.
-        def sync(revision, destination)
-          p4_sync(revision, destination, "-f")
-        end
-
-        # Returns the command that will sync the given revision to the given
-        # destination directory. The perforce client has a fixed destination so
-        # the files must be copied from there to their intended resting place.
-        def export(revision, destination)
-          p4_sync(revision, destination, "-f")
-        end
-               
-        # Returns the command that will do an "p4 diff2" for the two revisions.
-        def diff(from, to=head)
-          scm authentication, :diff2, "-u -db", "//#{p4client}/...#{rev_no(from)}", "//#{p4client}/...#{rev_no(to)}"
-        end
-
-        # Returns a "p4 changes" command for the two revisions.
-        def log(from=1, to=head)
-          scm authentication, :changes, "-s submitted", "//#{p4client}/...#{rev_no(from)},#(rev_no(to)}"
-        end
-
-        def query_revision(revision)
-          return revision if revision.to_s =~ /^\d+$/
-          command = scm(authentication, :changes, "-s submitted", "-m 1", "//#{p4client}/...#{rev_no(revision)}")
-          yield(command)[/Change (\d+) on/, 1]
-        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)
-          case text
-          when /\(P4PASSWD\) invalid or unset\./i
-	          raise Capistrano::Error, "scm_password (or p4passwd) is incorrect or unset"
-          when /Can.t create a new user.*/i
-	          raise Capistrano::Error, "scm_username (or p4user) is incorrect or unset"
-          when /Perforce client error\:/i	 
-	          raise Capistrano::Error, "p4port is incorrect or unset"
-          when /Client \'[\w\-\_\.]+\' unknown.*/i
-	          raise Capistrano::Error, "p4client is incorrect or unset"
-          end	             
-        end
-
-        private
-
-          # Builds the set of authentication switches that perforce understands.
-          def authentication
-            [ p4port   && "-p #{p4port}",
-              p4user   && "-u #{p4user}",
-              p4passwd && "-P #{p4passwd}",
-              p4client && "-c #{p4client}" ].compact.join(" ")
-          end
-
-          # Returns the command that will sync the given revision to the given
-          # destination directory with specific options. The perforce client has 
-          # a fixed destination so the files must be copied from there to their 
-          # intended resting place.          
-          def p4_sync(revision, destination, options="")
-            p4client_root = "`#{command} #{authentication} client -o | grep ^Root | cut -f2`"
-            scm authentication, :sync, options, "#{rev_no(revision)}", "&& cp -rf #{p4client_root} #{destination}"          
-          end
-
-          def p4client
-            variable(:p4client)
-          end
-
-          def p4port
-            variable(:p4port)
-          end
-
-          def p4user
-            variable(:p4user) || variable(:scm_username)
-          end
-          
-          def p4passwd
-            variable(:p4passwd) || variable(:scm_password)
-          end
-          
-          def rev_no(revision)                     
-            case revision.to_s
-            when "head"
-              "#head"
-            when /^\d+/  
-              "@#{revision}"
-            else
-              revision
-            end          
-          end
-      end
-
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-require 'yaml'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the Subversion revision
-      # control system (http://subversion.tigris.org).
-      class Subversion < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "svn"
-
-        # Subversion 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)
-          scm :checkout, verbose, authentication, "-r#{revision}", repository, destination
-        end
-
-        # Returns the command that will do an "svn update" to the given
-        # revision, for the working copy at the given destination.
-        def sync(revision, destination)
-          scm :update, verbose, authentication, "-r#{revision}", destination
-        end
-
-        # Returns the command that will do an "svn export" of the given revision
-        # to the given destination.
-        def export(revision, destination)
-          scm :export, verbose, authentication, "-r#{revision}", repository, destination
-        end
-
-        # Returns the command that will do an "svn diff" for the two revisions.
-        def diff(from, to=nil)
-          scm :diff, repository, authentication, "-r#{from}:#{to || head}"
-        end
-
-        # Returns an "svn log" command for the two revisions.
-        def log(from, to=nil)
-          scm :log, repository, authentication, "-r#{from}:#{to || head}"
-        end
-
-        # Attempts to translate the given revision identifier to a "real"
-        # revision. If the identifier is an integer, it will simply be returned.
-        # Otherwise, this will yield a string of the commands it needs to be
-        # executed (svn info), and will extract the revision from the response.
-        def query_revision(revision)
-          return revision if revision =~ /^\d+$/
-          command = scm(:info, repository, authentication, "-r#{revision}")
-          result = yield(command)
-          yaml = YAML.load(result)
-          raise "tried to run `#{command}' and got unexpected result #{result.inspect}" unless Hash === yaml
-          yaml['Last Changed Rev'] || yaml['Revision']
-        end
-
-        # Increments the given revision number and returns it.
-        def next_revision(revision)
-          revision.to_i + 1
-        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
-            # subversion is prompting for a password
-            "#{variable(:scm_password) || variable(:password)}\n"
-          when %r{\(yes/no\)}
-            # subversion is asking whether or not to connect
-            "yes\n"
-          when /passphrase/i
-            # subversion is asking for the passphrase for the user's key
-            "#{variable(:scm_passphrase)}\n"
-          when /The entry \'(.+?)\' is no longer a directory/
-            raise Capisrano::Error, "subversion can't update because directory '#{$1}' was replaced. Please add it to svn:ignore."
-          when /accept \(t\)emporarily/
-            # subversion is asking whether to accept the certificate
-            "t\n"
-          end
-        end
-
-        private
-
-          # If a username is configured for the SCM, return the command-line
-          # switches for that. Note that we don't need to return the password
-          # switch, since Capistrano will check for that prompt in the output
-          # and will respond appropriately.
-          def authentication
-            username = variable(:scm_username)
-            return "" unless username
-            result = "--username #{variable(:scm_username)} "
-            result << "--password #{variable(:scm_password)} " unless variable(:scm_prefer_prompt)
-            result << "--no-auth-cache " unless variable(:scm_auth_cache)
-            result
-          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
-      end
-
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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/strategy/base.rb

@@ -1,64 +0,0 @@
-require 'capistrano/recipes/deploy/dependencies'
-
-module Capistrano
-  module Deploy
-    module Strategy
-
-      # This class defines the abstract interface for all Capistrano
-      # deployment strategies. Subclasses must implement at least the
-      # #deploy! method.
-      class Base
-        attr_reader :configuration
-
-        # Instantiates a strategy with a reference to the given configuration.
-        def initialize(config={})
-          @configuration = config
-        end
-
-        # Executes the necessary commands to deploy the revision of the source
-        # code identified by the +revision+ variable. Additionally, this
-        # should write the value of the +revision+ variable to a file called
-        # REVISION, in the base of the deployed revision. This file is used by
-        # other tasks, to perform diffs and such.
-        def deploy!
-          raise NotImplementedError, "`deploy!' is not implemented by #{self.class.name}"
-        end
-
-        # Performs a check on the remote hosts to determine whether everything
-        # is setup such that a deploy could succeed.
-        def check!
-          Dependencies.new(configuration) do |d|
-            d.remote.directory(configuration[:releases_path]).or("`#{configuration[:releases_path]}' does not exist. Please run `cap deploy:setup'.")
-            d.remote.writable(configuration[:deploy_to]).or("You do not have permissions to write to `#{configuration[:deploy_to]}'.")
-            d.remote.writable(configuration[:releases_path]).or("You do not have permissions to write to `#{configuration[:releases_path]}'.")
-          end
-        end
-          
-        protected
-
-          # This is to allow helper methods like "run" and "put" to be more
-          # easily accessible to strategy implementations.
-          def method_missing(sym, *args, &block)
-            if configuration.respond_to?(sym)
-              configuration.send(sym, *args, &block)
-            else
-              super
-            end
-          end
-
-        private
-
-          def logger
-            @logger ||= configuration[:logger] || Capistrano::Logger.new(:output => STDOUT)
-          end
-
-          # The revision to deploy. Must return a real revision identifier,
-          # and not a pseudo-id.
-          def revision
-            configuration[:real_revision]
-          end
-      end
-
-    end
-  end
-end

data/lib/capistrano/recipes/deploy/strategy/checkout.rb

@@ -1,20 +0,0 @@
-require 'capistrano/recipes/deploy/strategy/remote'
-
-module Capistrano
-  module Deploy
-    module Strategy
-
-      # Implements the deployment strategy which does an SCM checkout on each
-      # target host. This is the default deployment strategy for Capistrano.
-      class Checkout < Remote
-        protected
-
-          # Returns the SCM's checkout command for the revision to deploy.
-          def command
-            @command ||= source.checkout(revision, configuration[:release_path])
-          end
-      end
-
-    end
-  end
-end