capistrano 2.8.0 → 3.19.0

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

@@ -1,282 +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.
-      #
-      # 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, "master"
-      #
-      # Otherwise, HEAD is assumed.  I strongly suggest you set this.  HEAD is
-      # not always the best assumption.
-      #
-      # You may also set <tt>:remote</tt>, which will be used as a name for remote
-      # tracking of repositories. This option is intended for use with the
-      # <tt>:remote_cache</tt> strategy in a distributed git environment.
-      #
-      # For example in the projects <tt>config/deploy.rb</tt>:
-      #
-      #   set :repository, "#{scm_user}@somehost:~/projects/project.git"
-      #   set :remote, "#{scm_user}"
-      #
-      # Then each person with deploy priveledges can add the following to their
-      # local <tt>~/.caprc</tt> file:
-      #
-      #   set :scm_user, 'someuser'
-      #
-      # Now any time a person deploys the project, their repository will be
-      # setup as a remote git repository within the cached repository.
-      #
-      # 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
-      #
-      # For those that don't like to leave your entire repository on
-      # your production server you can:
-      #
-      #   set :deploy_via, :export
-      #
-      # To deploy from a local repository:
-      #
-      #   set :repository, "file://."
-      #   set :deploy_via, :copy
-      #
-      # AUTHORS
-      # -------
-      #
-      # Garry Dolley http://scie.nti.st
-      # Contributions by Geoffrey Grosenbach http://topfunky.com
-      #              Scott Chacon http://jointheconversation.org
-      #                          Alex Arnell http://twologic.com
-      #                                   and Phillip Goldenburg
-
-      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
-          variable(:branch) || 'HEAD'
-        end
-
-        def origin
-          variable(:remote) || 'origin'
-        end
-
-        # Performs a clone on the remote machine, then checkout on the branch
-        # you want to deploy.
-        def checkout(revision, destination)
-          git    = command
-          remote = origin
-
-          args = []
-          args << "-o #{remote}" unless remote == 'origin'
-          if depth = variable(:git_shallow_clone)
-            args << "--depth #{depth}"
-          end
-
-          execute = []
-          execute << "#{git} clone #{verbose} #{args.join(' ')} #{variable(:repository)} #{destination}"
-
-          # checkout into a local branch rather than a detached HEAD
-          execute << "cd #{destination} && #{git} checkout #{verbose} -b deploy #{revision}"
-
-          if variable(:git_enable_submodules)
-            execute << "#{git} submodule #{verbose} init"
-            execute << "#{git} submodule #{verbose} sync"
-            if false == variable(:git_submodules_recursive)
-              execute << "#{git} submodule #{verbose} update --init"
-            else
-              execute << "#{git} submodule #{verbose} update --init --recursive"
-            end
-          end
-
-          execute.join(" && ").compact
-        end
-
-        # An expensive export. Performs a checkout as above, then
-        # removes the repo.
-        def export(revision, destination)
-          checkout(revision, destination) << " && rm -Rf #{destination}/.git"
-        end
-
-        # Merges the changes to 'head' since the last fetch, for remote_cache
-        # deployment strategy
-        def sync(revision, destination)
-          git     = command
-          remote  = origin
-
-          execute = []
-          execute << "cd #{destination}"
-
-          # Use git-config to setup a remote tracking branches. Could use
-          # git-remote but it complains when a remote of the same name already
-          # exists, git-config will just silenty overwrite the setting every
-          # time. This could cause wierd-ness in the remote cache if the url
-          # changes between calls, but as long as the repositories are all
-          # based from each other it should still work fine.
-          if remote != 'origin'
-            execute << "#{git} config remote.#{remote}.url #{variable(:repository)}"
-            execute << "#{git} config remote.#{remote}.fetch +refs/heads/*:refs/remotes/#{remote}/*"
-          end
-
-          # since we're in a local branch already, just reset to specified revision rather than merge
-          execute << "#{git} fetch #{verbose} #{remote} && #{git} fetch --tags #{verbose} #{remote} && #{git} reset #{verbose} --hard #{revision}"
-
-          if variable(:git_enable_submodules)
-            execute << "#{git} submodule #{verbose} init"
-            execute << "for mod in `#{git} submodule status | awk '{ print $2 }'`; do #{git} config -f .git/config submodule.${mod}.url `#{git} config -f .gitmodules --get submodule.${mod}.url` && echo Synced $mod; done"
-            execute << "#{git} submodule #{verbose} sync"
-            if false == variable(:git_submodules_recursive)
-              execute << "#{git} submodule #{verbose} update --init"
-            else
-              execute << "#{git} submodule #{verbose} update --init --recursive"
-            end
-          end
-
-          # Make sure there's nothing else lying around in the repository (for
-          # example, a submodule that has subsequently been removed).
-          execute << "#{git} clean #{verbose} -d -x -f"
-
-          execute.join(" && ")
-        end
-
-        # Returns a string of diffs between two revisions
-        def diff(from, to=nil)
-          return scm :diff, from unless to
-          scm :diff, "#{from}..#{to}"
-        end
-
-        # Returns a log of changes between the two revisions (inclusive).
-        def log(from, to=nil)
-          scm :log, "#{from}..#{to}"
-        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)
-          raise ArgumentError, "Deploying remote branches is no longer supported.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
-          return revision if revision =~ /^[0-9a-f]{40}$/
-          command = scm('ls-remote', repository, revision)
-          result = yield(command)
-          revdata = result.split(/[\t\n]/)
-          newrev = nil
-          revdata.each_slice(2) do |refs|
-            rev, ref = *refs
-            if ref.sub(/refs\/.*?\//, '').strip == revision.to_s
-              newrev = rev
-              break
-            end
-          end
-          raise "Unable to resolve revision for '#{revision}' on repository '#{repository}'." unless newrev =~ /^[0-9a-f]{40}$/
-          return newrev
-        end
-
-        def command
-          # For backwards compatibility with 1.x version of this module
-          variable(: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)
-          host = state[:channel][:host]
-          logger.info "[#{host} :: #{stream}] #{text}"
-          case text
-          when /\bpassword.*:/i
-            # git is prompting for a password
-            unless pass = variable(: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 = variable(: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
-
-        private
-
-          # If verbose output is requested, return nil, otherwise return the
-          # command-line switch for "quiet" ("-q").
-          def verbose
-            variable(:scm_verbose, true) ? "-q" : nil
-          end
-      end
-    end
-  end
-end

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

@@ -1,137 +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
-          variable(:branch) || "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)
-          host = state[:channel][:host]
-          logger.info "[#{host} :: #{stream}] #{text}"
-          case text
-          when /^user:/mi
-            # support :scm_user for backwards compatibility of this module
-            if user = variable(:scm_username) || variable(:scm_user)
-              "#{user}\n"
-            else
-              raise "No variable :scm_username specified and Mercurial asked!\n" +
-                "Prompt was: #{text}"
-            end
-          when /\bpassword:/mi
-            unless pass = scm_password_or_prompt
-              # fall back on old behavior of erroring out with msg
-              raise "No variable :scm_password specified and Mercurial asked!\n" +
-                "Prompt was: #{text}"
-            end
-            "#{pass}\n"
-          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   then nil
-            when false then "--quiet"
-            else            "--verbose"
-          end
-        end
-        
-        # honor Cap 2.1+'s :scm_prefer_prompt if present
-        def scm_password_or_prompt
-          @scm_password_or_prompt ||= variable(:scm_password) ||
-            (Capistrano::CLI.password_prompt("hg password: ") if variable(:scm_prefer_prompt))
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # A trivial SCM wrapper for representing the current working directory
-      # as a repository. Obviously, not all operations are available for this
-      # SCM, but it works sufficiently for use with the "copy" deployment
-      # strategy.
-      #
-      # Use of this module is _not_ recommended; in general, it is good
-      # practice to use some kind of source code management even for anything
-      # you are wanting to deploy. However, this module is provided in
-      # acknowledgement of the cases where trivial deployment of your current
-      # working directory is desired.
-      #
-      #   set :repository, "."
-      #   set :scm, :none
-      #   set :deploy_via, :copy
-      class None < Base
-        # No versioning, thus, no head. Returns the empty string.
-        def head
-          ""
-        end
-
-        # Simply does a copy from the :repository directory to the
-        # :destination directory.
-        def checkout(revision, destination)
-          !Capistrano::Deploy::LocalDependency.on_windows? ? "cp -R #{repository} #{destination}" : "xcopy #{repository} \"#{destination}\" /S/I/Y/Q/E"
-        end
-
-        alias_method :export, :checkout
-
-        # No versioning, so this just returns the argument, with no
-        # modification.
-        def query_revision(revision)
-          revision
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,138 +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, p4sync_flags)
-        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, p4sync_flags)
-        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, p4sync_flags)
-        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
-
-        # 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)
-          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="")
-            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 p4sync_flags
-            variable(:p4sync_flags) || "-f"
-          end
-
-          def p4client_root
-            variable(:p4client_root) || "`#{command} #{authentication} client -o | grep ^Root | cut -f2`"
-          end
-          
-          def rev_no(revision)                     
-            case revision.to_s
-            when "head"
-              "#head"
-            when /^\d+/  
-              "@#{revision}"
-            else
-              revision
-            end          
-          end
-      end
-
-    end
-  end
-end