capistrano 2.15.11 → 3.0.0.pre

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

@@ -1,96 +0,0 @@
-require 'capistrano/recipes/deploy/scm/base'
-
-module Capistrano
-  module Deploy
-    module SCM
-
-      # Implements the Capistrano SCM interface for the darcs revision
-      # control system (http://www.abridgegame.org/darcs/).
-      class Darcs < Base
-        # Sets the default command name for this SCM. Users may override this
-        # by setting the :scm_command variable.
-        default_command "darcs"
-
-        # Because darcs does not have any support for pseudo-ids, we'll just
-        # return something here that we can use in the helpers below for
-        # determining whether we need to look up the latest revision.
-        def head
-          :head
-        end
-
-        def to_match(revision)
-          if revision.nil? || revision == self.head
-            nil
-          else
-            "--to-match='hash #{revision}'"
-          end
-        end
-
-        # Returns the command that will check out the given revision to the
-        # given destination. The 'revision' parameter must be the 'hash' value
-        # for the revision in question, as given by 'darcs changes --xml-output'.
-        def checkout(revision, destination)
-          scm :get, *[verbose,
-                      "--repo-name=#{destination}",
-                      to_match(revision),
-                      repository].compact
-        end
-
-        # Tries to update the destination repository in-place, to bring it up
-        # to the given revision. Note that because darcs' "pull" operation
-        # does not support a "to-match" argument (or similar), this basically
-        # nukes the destination directory and re-gets it.
-        def sync(revision, destination)
-          ["rm -rf #{destination}", checkout(revision, destination)].join(" && ")
-        end
-
-        # Darcs does not have a real 'export' option; there is 'darcs dist',
-        # but that presupposes a utility that can untar and ungzip the dist
-        # file. We'll cheat and just do a get, followed by a deletion of the
-        # _darcs metadata directory.
-        def export(revision, destination)
-          [checkout(revision, destination), "rm -rf #{destination}/_darcs"].join(" && ")
-        end
-
-        # Returns the command that will do a "darcs diff" for the two revisions.
-        # Each revision must be the 'hash' identifier of a darcs revision.
-        def diff(from, to=nil)
-          scm :diff, "--from-match 'hash #{from}'", to && "--to-match 'hash #{to}'"
-        end
-
-        # Returns the log of changes between the two revisions. Each revision
-        # must be the 'hash' identifier of a darcs revision.
-        def log(from, to=nil)
-          scm :changes, "--from-match 'hash #{from}'", to && "--to-match 'hash #{to}'", "--repo=#{repository}"
-        end
-
-        # Attempts to translate the given revision identifier to a "real"
-        # revision. If the identifier is a symbol, it is assumed to be a
-        # pseudo-id. Otherwise, it will be immediately returned. If it is a
-        # pseudo-id, a set of commands to execute will be yielded, and the
-        # result of executing those commands must be returned by the block.
-        # This method will then extract the actual revision hash from the
-        # returned data.
-        def query_revision(revision)
-          case revision
-          when :head
-            xml = yield(scm(:changes, "--last 1", "--xml-output", "--repo=#{repository}"))
-            return xml[/hash='(.*?)'/, 1]
-          else return revision
-          end
-        end
-
-        private
-
-          def verbose
-            case variable(:scm_verbose)
-            when nil then "-q"
-            when false then nil
-            else "-v"
-            end
-          end
-      end
-
-    end
-  end
-end

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

@@ -1,299 +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 = []
-
-          # Add an option for the branch name so :git_shallow_clone works with branches
-          args << "-b #{variable(:branch)}" unless variable(:branch).nil? || variable(:branch) == revision
-          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 << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
-              execute << "#{git} submodule #{verbose} update --init $GIT_RECURSIVE"
-            end
-          end
-
-          execute.compact.join(" && ").gsub(/\s+/, ' ')
-        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 << "#{git} submodule #{verbose} sync"
-            if false == variable(:git_submodules_recursive)
-              execute << "#{git} submodule #{verbose} update --init"
-            else
-              execute << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
-              execute << "#{git} submodule #{verbose} update --init $GIT_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
-          return newrev if newrev =~ /^[0-9a-f]{40}$/
-
-          # If sha is not found on remote, try expanding from local repository
-          command = scm('rev-parse --revs-only', origin + '/' + revision)
-          newrev = yield(command).to_s.strip
-
-          # fallback for expected legacy default functionality
-          unless newrev =~ /^[0-9a-f]{40}$/
-            command = scm('rev-parse --revs-only', revision)
-            newrev = yield(command).to_s.strip
-          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) ? nil : "-q"
-          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,55 +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
-      #
-      #   Dereference symbolic links. Copy files instead. Handy when you
-      #   reference files and directory outside of your deployment root.
-      #   set :copy_dereference_symlink, true
-
-      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#{configuration[:copy_dereference_symlink]?'L':''} #{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
-
-        # log: There's no log, so it just echos from and to.
-
-        def log(from="", to="")
-          "No SCM: #{from} - #{to}"
-        end
-
-      end
-
-    end
-  end
-end