capistrano 2.0.0 → 2.15.9

data/lib/capistrano/configuration/namespaces.rb

@@ -32,6 +32,12 @@ module Capistrano
       end
       private :initialize_with_namespaces
 
+      # Returns the top-level namespace (the one with no parent).
+      def top
+        return parent.top if parent
+        return self
+      end
+
       # Returns the fully-qualified name of this namespace, or nil if the
       # namespace is at the top-level.
       def fully_qualified_name
@@ -61,7 +67,7 @@ module Capistrano
         raise ArgumentError, "expected a block" unless block_given?
 
         namespace_already_defined = namespaces.key?(name)
-        if all_methods.include?(name.to_s) && !namespace_already_defined
+        if all_methods.any? { |m| m.to_sym == name } && !namespace_already_defined
           thing = tasks.key?(name) ? "task" : "method"
           raise ArgumentError, "defining a namespace named `#{name}' would shadow an existing #{thing} with that name"
         end
@@ -86,17 +92,22 @@ module Capistrano
         raise ArgumentError, "expected a block" unless block_given?
 
         task_already_defined = tasks.key?(name)
-        if all_methods.include?(name.to_s) && !task_already_defined
+        if all_methods.any? { |m| m.to_sym == name } && !task_already_defined
           thing = namespaces.key?(name) ? "namespace" : "method"
           raise ArgumentError, "defining a task named `#{name}' would shadow an existing #{thing} with that name"
         end
 
-        tasks[name] = TaskDefinition.new(name, self, {:desc => next_description(:reset)}.merge(options), &block)
 
-        if !task_already_defined
-          metaclass = class << self; self; end
-          metaclass.send(:define_method, name) { execute_task(tasks[name]) }
-        end
+        task = TaskDefinition.new(name, self, {:desc => next_description(:reset)}.merge(options), &block)
+
+        define_task(task)
+      end
+
+      def define_task(task)
+        tasks[task.name] = task
+
+        metaclass = class << self; self; end
+        metaclass.send(:define_method, task.name) { execute_task(tasks[task.name]) }
       end
 
       # Find the task with the given name, where name is the fully-qualified
@@ -110,7 +121,8 @@ module Capistrano
 
         ns = self
         until parts.empty?
-          ns = ns.namespaces[parts.shift.to_sym]
+          next_part = parts.shift
+          ns = next_part.empty? ? nil : ns.namespaces[next_part.to_sym]
           return nil if ns.nil?
         end
 
@@ -144,7 +156,7 @@ module Capistrano
         return nil if parent.nil?
         return tasks[DEFAULT_TASK]
       end
-  
+
       # Returns the tasks in this namespace as an array of TaskDefinition
       # objects. If a non-false parameter is given, all tasks in all
       # namespaces under this namespace will be returned as well.
@@ -170,8 +182,8 @@ module Capistrano
             raise NotImplementedError, "roles cannot be defined in a namespace"
           end
 
-          def respond_to?(sym)
-            super || parent.respond_to?(sym)
+          def respond_to?(sym, include_priv=false)
+            super || parent.respond_to?(sym, include_priv)
           end
 
           def method_missing(sym, *args, &block)
@@ -182,9 +194,30 @@ module Capistrano
             end
           end
 
+          include Capistrano::Configuration::AliasTask
           include Capistrano::Configuration::Namespaces
           undef :desc, :next_description
         end
     end
   end
-end
+end
+
+module Kernel
+  class << self
+    alias_method :method_added_without_capistrano, :method_added
+
+    # Detect method additions to Kernel and remove them in the Namespace class
+    def method_added(name)
+      result = method_added_without_capistrano(name)
+      return result if self != Kernel
+
+      namespace = Capistrano::Configuration::Namespaces::Namespace
+
+      if namespace.method_defined?(name) && namespace.instance_method(name).owner == Kernel
+        namespace.send :undef_method, name
+      end
+
+      result
+    end
+  end
+end

data/lib/capistrano/configuration/roles.rb

@@ -1,4 +1,5 @@
 require 'capistrano/server_definition'
+require 'capistrano/role'
 
 module Capistrano
   class Configuration
@@ -15,7 +16,7 @@ module Capistrano
 
       def initialize_with_roles(*args) #:nodoc:
         initialize_without_roles(*args)
-        @roles = Hash.new { |h,k| h[k] = [] }
+        @roles = Hash.new { |h,k| h[k] = Role.new }
       end
 
       # Define a new role and its associated servers. You must specify at least
@@ -41,11 +42,42 @@ module Capistrano
       # that call to "role":
       #
       #   role :web, "web2", "web3", :user => "www", :port => 2345
-      def role(which, *args)
+      def role(which, *args, &block)
         options = args.last.is_a?(Hash) ? args.pop : {}
         which = which.to_sym
+
+        # The roles Hash is defined so that unrecognized keys always auto-initialize
+        # to a new Role instance (see the assignment in the initialize_with_roles method,
+        # above). However, we explicitly assign here so that role declarations will
+        # vivify the role object even if there are no server arguments. (Otherwise,
+        # role(:app) won't actually instantiate a Role object for :app.)
+        roles[which] ||= Role.new
+
+        roles[which].push(block, options) if block_given?
         args.each { |host| roles[which] << ServerDefinition.new(host, options) }
       end
+
+      # An alternative way to associate servers with roles. If you have a server
+      # that participates in multiple roles, this can be a DRYer way to describe
+      # the relationships. Pass the host definition as the first parameter, and
+      # the roles as the remaining parameters:
+      #
+      #   server "master.example.com", :web, :app
+      #
+      # Also, you can specify additional information
+      # (in the form of a Hash) which can be used to more uniquely specify the
+      # subset of servers specified by this specific definition:
+      #
+      #   server "master.example.com", :db, :primary => true
+      def server(host, *roles)
+        options = roles.last.is_a?(Hash) ? roles.pop : {}
+        raise ArgumentError, "you must associate a server with at least one role" if roles.empty?
+        roles.each { |name| role(name, host, options) }
+      end
+
+      def role_names_for_host(host)
+        roles.map {|role_name, role| role_name if role.include?(host) }.compact || []
+      end
     end
   end
 end

data/lib/capistrano/configuration/servers.rb

@@ -13,14 +13,22 @@ module Capistrano
       # The options hash may include a :hosts option (which should specify
       # an array of host names or ServerDefinition instances), a :roles
       # option (specifying an array of roles), an :only option (specifying
-      # a hash of key/value pairs that any matching server must match), and
-      # an :exception option (like :only, but the inverse).
+      # a hash of key/value pairs that any matching server must match),
+      # an :except option (like :only, but the inverse), and a
+      # :skip_hostfilter option to ignore the HOSTFILTER environment variable
+      # described below.
       #
       # Additionally, if the HOSTS environment variable is set, it will take
       # precedence over any other options. Similarly, the ROLES environment
       # variable will take precedence over other options. If both HOSTS and
       # ROLES are given, HOSTS wins.
       #
+      # Yet additionally, if the HOSTFILTER environment variable is set, it
+      # will limit the result to hosts found in that (comma-separated) list.
+      #
+      # If the HOSTROLEFILTER environment variable is set, it will limit the
+      # result to hosts found in that (comma-separated) list of roles
+      #
       # Usage:
       #
       #   # return all known servers
@@ -34,23 +42,57 @@ module Capistrano
       #   # returns the given hosts, translated to ServerDefinition objects
       #   servers = find_servers :hosts => "jamis@example.host.com"
       def find_servers(options={})
+        return [] if options.key?(:hosts) && (options[:hosts].nil? || [] == options[:hosts])
+        return [] if options.key?(:roles) && (options[:roles].nil? || [] == options[:roles])
+
         hosts  = server_list_from(ENV['HOSTS'] || options[:hosts])
-        roles  = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
-        only   = options[:only] || {}
-        except = options[:except] || {}
 
         if hosts.any?
-          hosts.uniq
+          if options[:skip_hostfilter]
+            hosts.uniq
+          else
+            filter_server_list(hosts.uniq)
+          end
         else
-          servers = roles.inject([]) { |list, role| list.concat(self.roles[role]) }
+          roles = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
+          roles = roles & Array(options[:roles]) if preserve_roles && !options[:roles].nil?
+
+          only   = options[:only] || {}
+          except = options[:except] || {}
+
+          # If we don't have a def for a role it means its bogus, skip it so higher level can handle
+          servers = roles.inject([]) { |list, role| list.concat(self.roles[role] || []) }
           servers = servers.select { |server| only.all? { |key,value| server.options[key] == value } }
           servers = servers.reject { |server| except.any? { |key,value| server.options[key] == value } }
-          servers.uniq
+
+          if options[:skip_hostfilter]
+            servers.uniq
+          else
+            filter_server_list(servers.uniq)
+          end
         end
       end
 
     protected
 
+      def filter_server_list(servers)
+        return servers unless ENV['HOSTFILTER'] or ENV['HOSTROLEFILTER']
+        if ENV['HOSTFILTER']
+          filters = ENV['HOSTFILTER'].split(/,/)
+          servers.select { |server| filters.include?(server.host) }
+        elsif ENV['HOSTROLEFILTER']
+          filters = ENV['HOSTROLEFILTER'].split(/,/).map do |role|
+            local_roles = roles[role.to_sym]
+            if local_roles.is_a? Array
+              roles[role.to_sym]
+            else
+              roles[role.to_sym].servers
+            end
+          end.flatten
+          servers.select { |server| filters.include?(server) }
+        end
+      end
+
       def server_list_from(hosts)
         hosts = hosts.split(/,/) if String === hosts
         hosts = build_list(hosts)
@@ -62,7 +104,6 @@ module Capistrano
         roles = build_list(roles)
         roles.map do |role|
           role = String === role ? role.strip.to_sym : role
-          raise ArgumentError, "unknown role `#{role}'" unless self.roles.key?(role)
           role
         end
       end
@@ -72,4 +113,4 @@ module Capistrano
       end
     end
   end
-end
+end

data/lib/capistrano/configuration/variables.rb

@@ -111,8 +111,8 @@ module Capistrano
       end
       private :protect
 
-      def respond_to_with_variables?(sym) #:nodoc:
-        @variables.has_key?(sym) || respond_to_without_variables?(sym)
+      def respond_to_with_variables?(sym, include_priv=false) #:nodoc:
+        @variables.has_key?(sym.to_sym) || respond_to_without_variables?(sym, include_priv)
       end
 
       def method_missing_with_variables(sym, *args, &block) #:nodoc:
@@ -124,4 +124,4 @@ module Capistrano
       end
     end
   end
-end
+end

data/lib/capistrano/configuration.rb

@@ -1,9 +1,11 @@
 require 'capistrano/logger'
 
+require 'capistrano/configuration/alias_task'
 require 'capistrano/configuration/callbacks'
 require 'capistrano/configuration/connections'
 require 'capistrano/configuration/execution'
 require 'capistrano/configuration/loading'
+require 'capistrano/configuration/log_formatters'
 require 'capistrano/configuration/namespaces'
 require 'capistrano/configuration/roles'
 require 'capistrano/configuration/servers'
@@ -19,10 +21,13 @@ module Capistrano
   # define roles, and set configuration variables.
   class Configuration
     # The logger instance defined for this configuration.
-    attr_accessor :logger
+    attr_accessor :debug, :logger, :dry_run, :preserve_roles
 
-    def initialize #:nodoc:
-      @logger = Logger.new
+    def initialize(options={}) #:nodoc:
+      @debug = false
+      @dry_run = false
+      @preserve_roles = false
+      @logger = Logger.new(options)
     end
 
     # make the DSL easier to read when using lazy evaluation via lambdas
@@ -30,12 +35,23 @@ module Capistrano
 
     # The includes must come at the bottom, since they may redefine methods
     # defined in the base class.
-    include Connections, Execution, Loading, Namespaces, Roles, Servers, Variables
+    include AliasTask, Connections, Execution, Loading, LogFormatters, Namespaces, Roles, Servers, Variables
 
     # Mix in the actions
     include Actions::FileTransfer, Actions::Inspect, Actions::Invocation
 
     # Must mix last, because it hooks into previously defined methods
     include Callbacks
+
+    (self.instance_methods & Kernel.methods).select do |name|
+      # Select the instance methods owned by the Configuration class.
+      self.instance_method(name).owner.to_s.start_with?("Capistrano::Configuration")
+    end.select do |name|
+      # Of those, select methods that are being shadowed by the Kernel module in the Namespace class.
+      Namespaces::Namespace.method_defined?(name) && Namespaces::Namespace.instance_method(name).owner == Kernel
+    end.each do |name|
+      # Undefine the shadowed methods, since we want Namespace objects to defer handling to the Configuration object.
+      Namespaces::Namespace.send(:undef_method, name)
+    end
   end
 end

data/lib/capistrano/errors.rb

@@ -1,15 +1,19 @@
 module Capistrano
-  class Error < RuntimeError; end
 
-  class CaptureError < Error; end
-  class NoSuchTaskError < Error; end
-  class NoMatchingServersError < Error; end
-  
+  Error = Class.new(RuntimeError)
+
+  CaptureError            = Class.new(Capistrano::Error)
+  NoSuchTaskError         = Class.new(Capistrano::Error)
+  NoMatchingServersError  = Class.new(Capistrano::Error)
+
   class RemoteError < Error
     attr_accessor :hosts
   end
 
-  class ConnectionError < RemoteError; end
-  class UploadError < RemoteError; end
-  class CommandError < RemoteError; end
+  ConnectionError     = Class.new(Capistrano::RemoteError)
+  TransferError       = Class.new(Capistrano::RemoteError)
+  CommandError        = Class.new(Capistrano::RemoteError)
+
+  LocalArgumentError  = Class.new(Capistrano::Error)
+
 end

data/lib/capistrano/ext/multistage.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "capistrano/ext/multistage requires Capistrano 2"
+end
+
+Capistrano::Configuration.instance.load do
+  location = fetch(:stage_dir, "config/deploy")
+
+  unless exists?(:stages)
+    set :stages, Dir["#{location}/*.rb"].map { |f| File.basename(f, ".rb") }
+  end
+
+  stages.each do |name|
+    desc "Set the target stage to `#{name}'."
+    task(name) do
+      set :stage, name.to_sym
+
+      file = "#{location}/#{stage}"
+      load file if file_in_load_path?(file)
+    end
+  end
+
+  on :load do
+    # The first non option argument
+    env = ARGV.detect { |a| a.to_s !~ /\A-/ && a.to_s !~ /=/ }
+
+    if stages.include?(env)
+      # Execute the specified stage so that recipes required in stage can contribute to task list
+      find_and_execute_task(env) if ARGV.any?{ |option| option =~ /-T|--tasks|-e|--explain/ }
+    else
+      # Execute the default stage so that recipes required in stage can contribute tasks
+      find_and_execute_task(default_stage) if exists?(:default_stage)
+    end
+  end
+
+  namespace :multistage do
+    desc "[internal] Ensure that a stage has been selected."
+    task :ensure do
+      if !exists?(:stage)
+        if exists?(:default_stage)
+          logger.important "Defaulting to `#{default_stage}'"
+          find_and_execute_task(default_stage)
+        else
+          abort "No stage specified. Please specify one of: #{stages.join(', ')} (e.g. `cap #{stages.first} #{ARGV.last}')"
+        end
+      end
+    end
+
+    desc "Stub out the staging config files."
+    task :prepare do
+      FileUtils.mkdir_p(location)
+      stages.each do |name|
+        file = File.join(location, name + ".rb")
+        unless File.exists?(file)
+          File.open(file, "w") do |f|
+            f.puts "# #{name.upcase}-specific deployment configuration"
+            f.puts "# please put general deployment config in config/deploy.rb"
+          end
+        end
+      end
+    end
+  end
+
+  on :start, "multistage:ensure", :except => stages + ['multistage:prepare']
+
+end

data/lib/capistrano/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def compact
+    self.gsub(/\s+/, ' ')
+  end
+end

data/lib/capistrano/extensions.rb

@@ -25,7 +25,7 @@ module Capistrano
       Capistrano::Configuration.protected_instance_methods +
       Capistrano::Configuration.private_instance_methods
 
-    if methods.include?(name.to_s)
+    if methods.any? { |m| m.to_sym == name }
       raise Capistrano::Error, "registering a plugin named `#{name}' would shadow a method on Capistrano::Configuration with the same name"
     end
 

data/lib/capistrano/fix_rake_deprecated_dsl.rb

@@ -0,0 +1,8 @@
+#
+# See https://github.com/jimweirich/rake/issues/81
+#
+if defined?(Rake::DeprecatedObjectDSL)
+  Rake::DeprecatedObjectDSL.private_instance_methods.each do |m|
+    Rake::DeprecatedObjectDSL.send("undef_method", m)
+  end
+end

data/lib/capistrano/logger.rb

@@ -1,15 +1,80 @@
 module Capistrano
   class Logger #:nodoc:
-    attr_accessor :level
-    attr_reader   :device
+    attr_accessor :level, :device, :disable_formatters
 
     IMPORTANT = 0
     INFO      = 1
     DEBUG     = 2
     TRACE     = 3
-    
+
     MAX_LEVEL = 3
 
+    COLORS = {
+      :none     => "0",
+      :black    => "30",
+      :red      => "31",
+      :green    => "32",
+      :yellow   => "33",
+      :blue     => "34",
+      :magenta  => "35",
+      :cyan     => "36",
+      :white    => "37"
+    }
+
+    STYLES = {
+      :bright     => 1,
+      :dim        => 2,
+      :underscore => 4,
+      :blink      => 5,
+      :reverse    => 7,
+      :hidden     => 8
+    }
+
+    # Set up default formatters
+    @default_formatters = [
+      # TRACE
+      { :match => /command finished/,          :color => :white,   :style => :dim, :level => 3, :priority => -10 },
+      { :match => /executing locally/,         :color => :yellow,  :level => 3, :priority => -20 },
+
+      # DEBUG
+      { :match => /executing `.*/,             :color => :green,   :level => 2, :priority => -10, :timestamp => true },
+      { :match => /.*/,                        :color => :yellow,  :level => 2, :priority => -30 },
+
+      # INFO
+      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :level => 1, :priority => -10 },
+      { :match => /Permission denied/,         :color => :red,     :level => 1, :priority => -20 },
+      { :match => /sh: .+: command not found/, :color => :magenta, :level => 1, :priority => -30 },
+
+      # IMPORTANT
+      { :match => /^err ::/,                   :color => :red,     :level => 0, :priority => -10 },
+      { :match => /.*/,                        :color => :blue,    :level => 0, :priority => -20 }
+    ]
+    @formatters = @default_formatters
+
+    class << self
+      def default_formatters
+        @default_formatters
+      end
+
+      def default_formatters=(defaults=nil)
+        @default_formatters = [defaults].flatten
+
+        # reset the formatters
+        @formatters = @default_formatters
+        @sorted_formatters = nil
+      end
+
+      def add_formatter(options) #:nodoc:
+        @formatters.push(options)
+        @sorted_formatters = nil
+      end
+
+      def sorted_formatters
+        # Sort matchers in reverse order so we can break if we found a match.
+        @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
+      end
+    end
+
     def initialize(options={})
       output = options[:output] || $stderr
       if output.respond_to?(:puts)
@@ -20,7 +85,8 @@ module Capistrano
       end
 
       @options = options
-      @level = 0
+      @level = options[:level] || 0
+      @disable_formatters = options[:disable_formatters]
     end
 
     def close
@@ -29,8 +95,44 @@ module Capistrano
 
     def log(level, message, line_prefix=nil)
       if level <= self.level
+        # Only format output if device is a TTY and formatters are not disabled
+        if device.tty? && !@disable_formatters
+          color = :none
+          style = nil
+
+          Logger.sorted_formatters.each do |formatter|
+            if (formatter[:level] == level || formatter[:level].nil?)
+              if message =~ formatter[:match] || line_prefix =~ formatter[:match]
+                color = formatter[:color] if formatter[:color]
+                style = formatter[:style] || formatter[:attribute] # (support original cap colors)
+                message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
+                message = formatter[:prepend] + message unless formatter[:prepend].nil?
+                message = message + formatter[:append] unless formatter[:append].nil?
+                message = Time.now.strftime('%Y-%m-%d %T') + ' ' + message if formatter[:timestamp]
+                break unless formatter[:replace]
+              end
+            end
+          end
+
+          if color == :hide
+            # Don't do anything if color is set to :hide
+            return false
+          end
+
+          term_color = COLORS[color]
+          term_style = STYLES[style]
+
+          # Don't format message if no color or style
+          unless color == :none and style.nil?
+            unless line_prefix.nil?
+              line_prefix = format(line_prefix, term_color, term_style, nil)
+            end
+            message = format(message, term_color, term_style)
+          end
+        end
+
         indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
-        message.each do |line|
+        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
           if line_prefix
             device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
           else
@@ -55,5 +157,10 @@ module Capistrano
     def trace(message, line_prefix=nil)
       log(TRACE, message, line_prefix)
     end
+
+    def format(message, color, style, nl = "\n")
+      style = "#{style};" if style
+      "\e[#{style}#{color}m" + message.to_s.strip + "\e[0m#{nl}"
+    end
   end
 end

data/lib/capistrano/processable.rb

@@ -0,0 +1,55 @@
+module Capistrano
+  module Processable
+    module SessionAssociation
+      def self.on(exception, session)
+        unless exception.respond_to?(:session)
+          exception.extend(self)
+          exception.session = session
+        end
+
+        return exception
+      end
+
+      attr_accessor :session
+    end
+
+    def process_iteration(wait=nil, &block)
+      ensure_each_session { |session| session.preprocess }
+
+      return false if block && !block.call(self)
+
+      readers = sessions.map { |session| session.listeners.keys }.flatten.reject { |io| io.closed? }
+      writers = readers.select { |io| io.respond_to?(:pending_write?) && io.pending_write? }
+
+      if readers.any? || writers.any?
+        readers, writers, = IO.select(readers, writers, nil, wait)
+      else
+        return false
+      end
+
+      if readers
+        ensure_each_session do |session|
+          ios = session.listeners.keys
+          session.postprocess(ios & readers, ios & writers)
+        end
+      end
+
+      true
+    end
+
+    def ensure_each_session
+      errors = []
+
+      sessions.each do |session|
+        begin
+          yield session
+        rescue Exception => error
+          errors << SessionAssociation.on(error, session)
+        end
+      end
+
+      raise errors.first if errors.any?
+      sessions
+    end
+  end
+end