capistrano 1.4.2 → 2.0.0

data/lib/capistrano/scm/cvs.rb

@@ -1,129 +0,0 @@
-require 'time'
-require 'capistrano/scm/base'
-
-module Capistrano
-  module SCM
-
-    # An SCM module for using CVS as your source control tool. You can
-    # specify it by placing the following line in your configuration:
-    #
-    #   set :scm, :cvs
-    #
-    # Also, this module accepts a <tt>:cvs</tt> configuration variable,
-    # which (if specified) will be used as the full path to the cvs
-    # executable on the remote machine:
-    #
-    #   set :cvs, "/opt/local/bin/cvs"
-    #
-    # You can specify the location of your local copy (used to query
-    # the revisions, etc.) via the <tt>:local</tt> variable, which defaults to
-    # ".".
-    #
-    # You may also specify a <tt>:branch</tt> configuration variable,
-    # which (if specified) will be used in the '-r' option to the cvs
-    # check out command.  If it is not set, the module will determine if a
-    # branch is being used in the CVS sandbox relative to
-    # <tt>:local</tt> and act accordingly.   
-    #
-    #   set :branch, "prod-20060124"
-    #
-    # Also, you can specify the CVS_RSH variable to use on the remote machine(s)
-    # via the <tt>:cvs_rsh</tt> variable. This defaults to the value of the
-    # CVS_RSH environment variable locally, or if it is not set, to "ssh".
-    class Cvs < Base
-      def initialize(configuration)
-        super(configuration)
-
-        if not @configuration.respond_to?(:local) then
-          @configuration.set(:local,".") 
-        end
-
-        if not configuration.respond_to?(:branch) then
-          configuration.set(:branch) { self.current_branch }
-        else
-          @current_branch = configuration[:branch]
-        end
-     end
-
-      # Return a string representing the date of the last revision (CVS is
-      # seriously retarded, in that it does not give you a way to query when
-      # the last revision was made to the repository, so this is a fairly
-      # expensive operation...)
-      def latest_revision
-        return @latest_revision if @latest_revision
-        configuration.logger.debug "querying latest revision..."
-        @latest_revision = cvs_log(cvs_local, configuration.branch).
-          split(/\r?\n/).
-          grep(/^date: (.*?);/) { Time.parse($1).strftime("%Y-%m-%d %H:%M:%S") }.
-          sort.
-          last
-      end
-
-      # Return a string representing the branch that the sandbox
-      # relative to <tt>:local</tt> contains.
-      def current_branch 
-        return @current_branch if @current_branch
-        configuration.logger.debug "determining current_branch..."
-        @current_branch = cvs_branch(cvs_local)
-      end
-
-      # Check out (on all servers associated with the current task) the latest
-      # revision, using a branch if necessary. Uses the given actor instance 
-      # to execute the command.
-      def checkout(actor)
-        cvs = configuration[:cvs] || "cvs"
-        cvs_rsh = configuration[:cvs_rsh] || ENV['CVS_RSH'] || "ssh"
-
-        if "HEAD" == configuration.branch then
-            branch_option = ""
-        else
-            branch_option = "-r #{configuration.branch}"
-        end
-
-        command = <<-CMD
-          cd #{configuration.releases_path};
-          CVS_RSH="#{cvs_rsh}" #{cvs} -d #{configuration.repository} -Q co -D "#{configuration.revision}" #{branch_option} -d #{File.basename(actor.release_path)} #{actor.application};
-        CMD
-
-        run_checkout(actor, command) do |ch, stream, out|
-          prefix = "#{stream} :: #{ch[:host]}"
-          actor.logger.info out, prefix
-          if out =~ %r{password:}
-            actor.logger.info "CVS is asking for a password", prefix
-            ch.send_data "#{actor.password}\n"
-          elsif out =~ %r{^Enter passphrase}
-            message = "CVS needs your key's passphrase and cannot proceed"
-            actor.logger.info message, prefix
-            raise message
-          end
-        end
-      end
-
-      private
-
-        # Look for a 'CVS/Tag' file in the path.  If this file exists
-        # and contains a Line starting with 'T' then this CVS sandbox is
-        # 'tagged' with a branch.  In the default case return 'HEAD'
-        def cvs_branch(path)
-          branch = "HEAD"
-          branch_file = File.join(path || ".", "CVS", "Tag")
-          if File.exists?(branch_file) then
-            File.open(branch_file) do |f|
-              possible_branch = f.find { |l| l =~ %r{^T} }
-              branch = possible_branch.strip[1..-1] if possible_branch
-            end
-          end
-          branch
-        end
-
-        def cvs_log(path,branch)
-          `cd #{path || "."} && cvs -d #{configuration.repository} -q log -N -r#{branch}`
-        end
-
-        def cvs_local
-          configuration.local || "."
-        end
-    end
-
-  end
-end

data/lib/capistrano/scm/darcs.rb

@@ -1,27 +0,0 @@
-require 'capistrano/scm/base'
-
-module Capistrano
-  module SCM
-
-    # An SCM module for using darcs as your source control tool. Use it by
-    # specifying the following line in your configuration:
-    #
-    #   set :scm, :darcs
-    #
-    # Also, this module accepts a <tt>:darcs</tt> configuration variable,
-    # which (if specified) will be used as the full path to the darcs
-    # executable on the remote machine:
-    #
-    #   set :darcs, "/opt/local/bin/darcs"
-    class Darcs < Base
-      # Check out (on all servers associated with the current task) the latest
-      # revision. Uses the given actor instance to execute the command.
-      def checkout(actor)
-        darcs = configuration[:darcs] ? configuration[:darcs] : "darcs"
-        revision = configuration[:revision] ? %(--to-match "#{configuration.revision}") : ""
-        run_checkout(actor, "#{darcs} get -q --set-scripts-executable #{revision} #{configuration.repository} #{actor.release_path};")
-      end
-    end
-
-  end
-end

data/lib/capistrano/scm/mercurial.rb

@@ -1,83 +0,0 @@
-require 'capistrano/scm/base'
-
-module Capistrano
-  module SCM
-
-    # An SCM module for using Mercurial as your source control tool.
-    # You can use it by placing the following line in your configuration:
-    #
-    #   set :scm, :mercurial
-    #
-    # Also, this module accepts a <tt>:mercurial</tt> configuration variable,
-    # which (if specified) will be used as the full path to the hg
-    # executable on the remote machine:
-    #
-    #   set :mercurial, "/usr/local/bin/hg"
-    class Mercurial < Base
-      # Return a string identifying the tip changeset in the mercurial
-      # repository. Note that this fetches the tip changeset from the
-      # local repository, but capistrano will deploy from your _remote_
-      # repository. So just make sure your local repository is synchronized
-      # with your remote one.
-      def latest_revision
-        `#{mercurial} tip --template '{node|short}'`
-      end
-
-      # Return the changeset currently deployed.
-      def current_revision(actor)
-        # NOTE:
-        # copied almost verbatim from svn except its not cast into an int
-        # this should be the same for almost _every_ scm can we take it out
-        # of SCM-specific code?
-        latest = actor.releases.last
-        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
-        result = ""
-        actor.run(grep, :once => true) do |ch, str, out|
-          result << out if str == :out
-          raise "could not determine current changeset" if str == :err
-        end
-
-        date, time, user, changeset, dir = result.split
-        raise "current changeset not found in revisions.log" unless dir == latest
-        changeset
-      end
-
-      # Return a string containing the diff between the two changesets. +from+
-      # and +to+ may be in any format that mercurial recognizes as a valid 
-      # changeset. If +from+ is +nil+, it defaults to the last deployed
-      # changeset. If +to+ is +nil+, it defaults to the current working
-      # directory.
-      def diff(actor, from = current_revision(actor), to = nil)
-        cmd = "#{mercurial} diff -r #{from}"
-        cmd << " -r #{to}" if to
-        `#{cmd}`
-      end
-
-      # Check out (on all servers associated with the current task) the latest
-      # revision. Uses the given actor instance to execute the command. If
-      # mercurial asks for a password this will automatically provide it
-      # (assuming the requested password is the same as the password for
-      # logging into the remote server.) If ssh repository method is used,
-      # authorized keys must be setup.
-      def checkout(actor)
-        command = "#{mercurial} clone -U #{configuration.repository} " +
-                  "#{actor.release_path} && " +
-                  "#{mercurial} -R #{actor.release_path} update " +
-                   "-C #{configuration.revision} &&"
-        run_checkout(actor, command, &hg_stream_handler(actor)) 
-      end
-
-      private
-      def mercurial
-        configuration[:mercurial] || "hg"
-      end
-
-      def hg_stream_handler(actor)
-        Proc.new do |ch, stream, out|
-          prefix = "#{stream} :: #{ch[:host]}"
-          actor.logger.info out, prefix
-        end
-      end
-    end
-  end
-end

data/lib/capistrano/scm/perforce.rb

@@ -1,139 +0,0 @@
-require 'capistrano/scm/base'
-
-module Capistrano
-  module SCM
-
-    # An SCM module for using perforce as your source control tool. 
-    # This module can explicitly selected by placing the following line 
-    # in your configuration:
-    #
-    #   set :scm, :perforce
-    #
-    # Also, this module accepts a <tt>:p4</tt> configuration variable,
-    # which (if specified) will be used as the full path to the p4
-    # executable on the remote machine:
-    #
-    #   set :p4, "/usr/local/bin/p4"
-    #
-    # This module accepts another <tt>:p4sync_flags</tt> configuration 
-    # variable, which (if specified) can add extra options. This setting
-    # defaults to the value "-f" which forces resynchronization.
-    #
-    #   set :p4sync_flags, "-f"        
-    #
-    # This module accepts another <tt>:p4client_root</tt> configuration 
-    # variable to handle mapping adjustments.  Perforce doesn't have the 
-    # ability to sync to a specific directory (e.g. the release_path); the
-    # location being synced to is defined by the client-spec. As such, we 
-    # sync the client-spec (defined by <tt>p4client</tt> and then copy from 
-    # the determined root of the client-spec mappings to the release_path.
-    # In the unlikely event that your client-spec mappings introduces 
-    # directory structure above the rails structure, you can override the
-    # may need to specify the directory
-    #
-    #   set :p4client_root, "/user/rmcmahon/project1/code"            
-    #
-    # Finally, the module accepts a <tt>p4diff2_options</tt> configuration
-    # variable. This can be used to manipulate the output when running a
-    # diff between what is deployed, and another revision. This option
-    # defaults to "-u". Run 'p4 help diff2' for other options.
-    #
-    class Perforce < Base
-
-      def latest_revision
-        configuration.logger.debug "querying latest revision..." unless @latest_revision
-        @latest_revision = `#{local_p4} counter change`.strip
-        @latest_revision
-      end
-      
-      # Return the number of the revision currently deployed.
-      def current_revision(actor)
-        latest = actor.releases.last
-        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
-        result = ""
-        actor.run(grep, :once => true) do |ch, str, out|
-          result << out if str == :out
-          raise "could not determine current revision" if str == :err
-        end
-
-        date, time, user, rev, dir = result.split
-        raise "current revision not found in revisions.log" unless dir == latest
-        rev.to_i
-      end
-      
-      # Return a string containing the diff between the two revisions. +from+
-      # and +to+ may be in any format that p4 recognizes as a valid revision
-      # identifiers. If +from+ is +nil+, it defaults to the last deployed
-      # revision. If +to+ is +nil+, it defaults to #head.
-      def diff(actor, from=nil, to=nil)
-        from ||= "@#{current_revision(actor)}"
-        to ||= "#head"
-        p4client = configuration[:p4client]
-        p4diff2_options = configuration[:p4diff2_options]||"-u -db"
-        `#{local_p4} diff2 #{p4diff2_options} //#{p4client}/...#{from} //#{p4client}/...#{to}`
-      end      
-      
-      # Syncronizes (on all servers associated with the current task) the head
-      # revision of the code. Uses the given actor instance to execute the command. 
-      #
-      def checkout(actor)
-        p4sync_flags = configuration[:p4sync_flags] || "-f"
-        p4client_root = configuration[:p4client_root] || "`#{remote_p4} client -o | grep ^Root | cut -f2`"
-        command = "#{remote_p4} sync #{p4sync_flags} && cp -rf #{p4client_root} #{actor.release_path};"
-        run_checkout(actor, command, &p4_stream_handler(actor)) 
-      end
-
-      def update(actor)
-        raise "#{self.class} doesn't support update(actor)"
-      end
-
-      private
-
-        def local_p4	  
-          add_standard_p4_options('p4')
-        end
-
-        def remote_p4	  
-          p4_cmd = configuration[:p4] || 'p4'
-          add_standard_p4_options(p4_cmd)
-        end
-	
-        def add_standard_p4_options(p4_location)
-          check_settings
-          p4_cmd = p4_location	  
-          p4_cmd = "#{p4_cmd} -p #{configuration[:p4port]}" if configuration[:p4port]
-          p4_cmd = "#{p4_cmd} -u #{configuration[:p4user]}" if configuration[:p4user]
-          p4_cmd = "#{p4_cmd} -P #{configuration[:p4passwd]}" if configuration[:p4passwd]
-          p4_cmd = "#{p4_cmd} -c #{configuration[:p4client]}" if configuration[:p4client]
-          p4_cmd	
-        end
-
-        def check_settings
-          check_setting(:p4port, "Add set :p4port, <your perforce server details e.g. my.p4.server:1666> to deploy.rb")
-          check_setting(:p4user, "Add set :p4user, <your production build username> to deploy.rb")
-          check_setting(:p4passwd, "Add set :p4passwd, <your build user password> to deploy.rb")
-          check_setting(:p4client, "Add set :p4client, <your client-spec name> to deploy.rb")
-        end
-	
-        def check_setting(p4setting, message)
-          raise "#{p4setting} is not configured. #{message}" unless configuration[p4setting]
-        end
-	
-        def p4_stream_handler(actor)
-          Proc.new do |ch, stream, out|
-            prefix = "#{stream} :: #{ch[:host]}"
-            actor.logger.info out, prefix
-            if out =~ /\(P4PASSWD\) invalid or unset\./i
-	            raise "p4passwd is incorrect or unset"
-            elsif out =~ /Can.t create a new user.*/i
-	            raise "p4user is incorrect or unset"
-            elsif out =~ /Perforce client error\:/i	      
-	            raise "p4port is incorrect or unset"
-            elsif out =~ /Client \'[\w\-\_\.]+\' unknown.*/i
-	            raise "p4client is incorrect or unset"
-            end	    
-          end
-        end	
-    end
-  end
-end

data/lib/capistrano/scm/subversion.rb

@@ -1,128 +0,0 @@
-require 'capistrano/scm/base'
-
-module Capistrano
-  module SCM
-
-    # An SCM module for using subversion as your source control tool. This
-    # module is used by default, but you can explicitly specify it by
-    # placing the following line in your configuration:
-    #
-    #   set :scm, :subversion
-    #
-    # Also, this module accepts a <tt>:svn</tt> configuration variable,
-    # which (if specified) will be used as the full path to the svn
-    # executable on the remote machine:
-    #
-    #   set :svn, "/opt/local/bin/svn"
-    class Subversion < Base
-      # Return an integer identifying the last known revision in the svn
-      # repository. (This integer is currently the revision number.)
-      def latest_revision
-        @latest_revision ||= begin
-            configuration.logger.debug "querying latest revision..."
-            match = svn_log(configuration.repository).scan(/r(\d+)/).first or
-              raise "Could not determine latest revision"
-            match.first
-          end
-      end
-
-      # Return the number of the revision currently deployed.
-      def current_revision(actor)
-        latest = actor.releases.last
-        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
-        result = ""
-        actor.run(grep, :once => true) do |ch, str, out|
-          result << out if str == :out
-          raise "could not determine current revision" if str == :err
-        end
-
-        date, time, user, rev, dir = result.split
-        raise "current revision not found in revisions.log" unless dir == latest
-
-        rev.to_i
-      end
-
-      # Return a string containing the diff between the two revisions. +from+
-      # and +to+ may be in any format that svn recognizes as a valid revision
-      # identifier. If +from+ is +nil+, it defaults to the last deployed
-      # revision. If +to+ is +nil+, it defaults to HEAD.
-      def diff(actor, from=nil, to=nil)
-        from ||= current_revision(actor)
-        to ||= "HEAD"
-
-        `svn diff #{authorization} #{configuration.repository}@#{from} #{configuration.repository}@#{to}`
-      end
-
-      # Check out (on all servers associated with the current task) the latest
-      # revision. Uses the given actor instance to execute the command. If
-      # svn asks for a password this will automatically provide it (assuming
-      # the requested password is the same as the password for logging into the
-      # remote server.)
-      def checkout(actor)
-        op = configuration[:checkout] || "co"
-        command = "#{svn} #{op} #{authorization} -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
-        run_checkout(actor, command, &svn_stream_handler(actor)) 
-      end
-
-      # Update the current release in-place. This assumes that the original
-      # deployment was made using checkout, and not something like export.
-      def update(actor)
-        command = "cd #{actor.current_path} && #{svn} up -q &&"
-        run_update(actor, command, &svn_stream_handler(actor)) 
-      end
-
-      private
-
-        def svn
-          configuration[:svn] || "svn"
-        end
-
-        def authorization
-          username = configuration[:svn_username] ? "--username #{configuration[:svn_username]}" : ""
-          password = configuration[:svn_password] ? "--password #{configuration[:svn_password]}" : ""
-          no_auth_cache = configuration[:svn_username] || configuration[:svn_password] ? "--no-auth-cache" : ""
-          "#{no_auth_cache} #{username} #{password}"
-        end
-
-        def svn_log(path)
-          `svn log #{authorization} -q --limit 1 #{path}`
-        end
-
-        def svn_password
-          configuration[:svn_password] || configuration[:password]
-        end
-
-        def svn_passphrase
-          configuration[:svn_passphrase] || svn_password
-        end
-        
-        def svn_stream_handler(actor)
-          Proc.new do |ch, stream, out|
-            prefix = "#{stream} :: #{ch[:host]}"
-            actor.logger.info out, prefix
-            if out =~ /\bpassword.*:/i
-              actor.logger.info "subversion is asking for a password", prefix
-              ch.send_data "#{svn_password}\n"
-            elsif out =~ %r{\(yes/no\)}
-              actor.logger.info "subversion is asking whether to connect or not",
-                prefix
-              ch.send_data "yes\n"
-            elsif out =~ %r{passphrase}i
-              message = "subversion needs your key's passphrase"
-              actor.logger.info message, prefix
-              ch.send_data "#{svn_passphrase}\n"
-            elsif out =~ %r{The entry \'(\w+)\' is no longer a directory}
-              message = "subversion can't update because directory '#{$1}' was replaced. Please add it to svn:ignore."
-              actor.logger.info message, prefix
-              raise message
-            elsif out =~ %r{accept \(t\)emporarily}
-              message = "accepting certificate temporarily"
-              actor.logger.info message, prefix
-              ch.send_data "t\n"
-            end
-          end
-        end
-    end
-
-  end
-end