Ticket #4150: hg.rb

# Please note that this code is heavily derived from the Bzr module for capistrano
# written by Damien Merenne.  Cheers and thanks for the help!

require 'capistrano/scm/base'

module Capistrano
  module SCM
    ID_REGEX =  /([[:xdigit:]]+)\+?\s(\w+\s+)*/
    SSH_REPO_REGEX = /ssh:\/\/(([[:alnum:]]+)@)?([a-zA-Z.-]+)\/(.+)/
    # An SCM module for using Mercurial (hg) as your source control tool.
    # You can use it by placing the following line in your configuration:
    #
    #   set :scm, :hg
    #
    # Also, this module accepts a <tt>:hg</tt> configuration variable,
    # which (if specified) will be used as the full path to the hg
    # executable on the remote machine:
    #
    #   set :hg, "/opt/local/bin/hg"
    #
    # SSH and Local repositories are supported, although a ssh repositories
    # require a little finagling to mesh well.  below is a typical repository 
    # line for SSH:
    #
    #   set(:repository) { "ssh://#{user}@nullstyle.com/hg/nullstyle.com" }
    #
    # that will ensure that the user that attemps the login is correct, whether
    # the :user variable is changed or not.
    class Hg < Base
      
      def latest_revision
        case repository_type(configuration.repository)
        when :local
          extract_revision `#{hg} -R #{directory} id`
        when :ssh
          host, directory = extract_host_and_dir(configuration.repository)
          extract_revision `ssh #{configuration.user}@#{host} #{hg} -R #{directory} id`
        end
      end

      # Return the number of the revision currently deployed.
      def current_revision(actor)
        command = "#{hg} -R #{actor.release_path} id &&"        
        extract_revision run_update(actor, command, &hg_stream_handler(actor)) 
      end

      # Check out (on all servers associated with the current task) the latest
      # revision. Uses the given actor instance to execute the command. If
      # hg 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] || "clone"
        command = "#{hg} -q #{op} #{configuration.repository} #{actor.release_path} && #{hg} -R #{actor.release_path} up #{configuration.revision} && "
        run_checkout(actor, command, &hg_stream_handler(actor)) 
      end

      def update(actor)
        command = "cd #{actor.current_path} && #{hg} pull -u -q &&"
        run_update(actor, command, &hg_stream_handler(actor)) 
      end
      
      private
        def hg
          configuration[:hg] || "hg"
        end
        
        def hg_password
          configuration[:hg_password] || configuration[:password]
        end

        def hg_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 "hg is asking for a password", prefix
              ch.send_data "#{hg_password}\n"
            elsif out =~ %r{\(yes/no\)}
              actor.logger.info "hg is asking whether to connect or not",
                prefix
              ch.send_data "yes\n"
            elsif out =~ %r{passphrase}
              message = "hg needs your key's passphrase, sending empty string"
              actor.logger.info message, prefix
              ch.send_data "\n"
            end
        
          end
        end
        
        def extract_revision(rev_string)
          ID_REGEX.match(rev_string)[1]  
        end
        
        def extract_host_and_dir(repository)
          match = SSH_REPO_REGEX.match repository
          [match[3],match[4]]
        end
        
        def repository_type(repository)
          if SSH_REPO_REGEX.match repository
            :ssh
          else
            :local
          end
        end
    end
  end
end