minmb-capistrano 2.15.4

data/lib/capistrano/configuration/variables.rb

@@ -0,0 +1,127 @@
+require 'thread'
+
+module Capistrano
+  class Configuration
+    module Variables
+      def self.included(base) #:nodoc:
+        %w(initialize respond_to? method_missing).each do |m|
+          base_name = m[/^\w+/]
+          punct     = m[/\W+$/]
+          base.send :alias_method, "#{base_name}_without_variables#{punct}", m
+          base.send :alias_method, m, "#{base_name}_with_variables#{punct}"
+        end
+      end
+
+      # The hash of variables that have been defined in this configuration
+      # instance.
+      attr_reader :variables
+
+      # Set a variable to the given value.
+      def set(variable, *args, &block)
+        if variable.to_s !~ /^[_a-z]/
+          raise ArgumentError, "invalid variable `#{variable}' (variables must begin with an underscore, or a lower-case letter)"
+        end
+
+        if !block_given? && args.empty? || block_given? && !args.empty?
+          raise ArgumentError, "you must specify exactly one of either a value or a block"
+        end
+
+        if args.length > 1
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+
+        value = args.empty? ? block : args.first
+        sym = variable.to_sym
+        protect(sym) { @variables[sym] = value }
+      end
+
+      alias :[]= :set
+
+      # Removes any trace of the given variable.
+      def unset(variable)
+        sym = variable.to_sym
+        protect(sym) do
+          @original_procs.delete(sym)
+          @variables.delete(sym)
+        end
+      end
+
+      # Returns true if the variable has been defined, and false otherwise.
+      def exists?(variable)
+        @variables.key?(variable.to_sym)
+      end
+
+      # If the variable was originally a proc value, it will be reset to it's
+      # original proc value. Otherwise, this method does nothing. It returns
+      # true if the variable was actually reset.
+      def reset!(variable)
+        sym = variable.to_sym
+        protect(sym) do
+          if @original_procs.key?(sym)
+            @variables[sym] = @original_procs.delete(sym)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # Access a named variable. If the value of the variable responds_to? :call,
+      # #call will be invoked (without parameters) and the return value cached
+      # and returned.
+      def fetch(variable, *args)
+        if !args.empty? && block_given?
+          raise ArgumentError, "you must specify either a default value or a block, but not both"
+        end
+
+        sym = variable.to_sym
+        protect(sym) do
+          if !@variables.key?(sym)
+            return args.first unless args.empty?
+            return yield(variable) if block_given?
+            raise IndexError, "`#{variable}' not found"
+          end
+
+          if @variables[sym].respond_to?(:call)
+            @original_procs[sym] = @variables[sym]
+            @variables[sym] = @variables[sym].call
+          end
+        end
+
+        @variables[sym]
+      end
+
+      def [](variable)
+        fetch(variable, nil)
+      end
+
+      def initialize_with_variables(*args) #:nodoc:
+        initialize_without_variables(*args)
+        @variables = {}
+        @original_procs = {}
+        @variable_locks = Hash.new { |h,k| h[k] = Mutex.new }
+
+        set :ssh_options, {}
+        set :logger, logger
+      end
+      private :initialize_with_variables
+
+      def protect(variable)
+        @variable_locks[variable.to_sym].synchronize { yield }
+      end
+      private :protect
+
+      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:
+        if args.length == 0 && block.nil? && @variables.has_key?(sym)
+          self[sym]
+        else
+          method_missing_without_variables(sym, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/errors.rb

@@ -0,0 +1,19 @@
+module Capistrano
+
+  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
+
+  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,64 @@
+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
+    if stages.include?(ARGV.first)
+      # Execute the specified stage so that recipes required in stage can contribute to task list
+      find_and_execute_task(ARGV.first) 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

@@ -0,0 +1,57 @@
+module Capistrano
+  class ExtensionProxy #:nodoc:
+    def initialize(config, mod)
+      @config = config
+      extend(mod)
+    end
+
+    def method_missing(sym, *args, &block)
+      @config.send(sym, *args, &block)
+    end
+  end
+
+  # Holds the set of registered plugins, keyed by name (where the name is a
+  # symbol).
+  EXTENSIONS = {}
+
+  # Register the given module as a plugin with the given name. It will henceforth
+  # be available via a proxy object on Configuration instances, accessible by
+  # a method with the given name.
+  def self.plugin(name, mod)
+    name = name.to_sym
+    return false if EXTENSIONS.has_key?(name)
+
+    methods = Capistrano::Configuration.public_instance_methods +
+      Capistrano::Configuration.protected_instance_methods +
+      Capistrano::Configuration.private_instance_methods
+
+    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
+
+    Capistrano::Configuration.class_eval <<-STR, __FILE__, __LINE__+1
+      def #{name}
+        @__#{name}_proxy ||= Capistrano::ExtensionProxy.new(self, Capistrano::EXTENSIONS[#{name.inspect}])
+      end
+    STR
+
+    EXTENSIONS[name] = mod
+    return true
+  end
+
+  # Unregister the plugin with the given name.
+  def self.remove_plugin(name)
+    name = name.to_sym
+    if EXTENSIONS.delete(name)
+      Capistrano::Configuration.send(:remove_method, name)
+      return true
+    end
+
+    return false
+  end
+
+  def self.configuration(*args) #:nodoc:
+    warn "[DEPRECATION] Capistrano.configuration is deprecated. Use Capistrano::Configuration.instance instead"
+    Capistrano::Configuration.instance(*args)
+  end
+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

@@ -0,0 +1,166 @@
+module Capistrano
+  class Logger #:nodoc:
+    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)
+        @device = output
+      else
+        @device = File.open(output.to_str, "a")
+        @needs_close = true
+      end
+
+      @options = options
+      @level = options[:level] || 0
+      @disable_formatters = options[:disable_formatters]
+    end
+
+    def close
+      device.close if @needs_close
+    end
+
+    def log(level, message, line_prefix=nil)
+      if level <= self.level
+        # Only format output if device is a TTY or 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)]
+        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
+          if line_prefix
+            device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
+          else
+            device.puts "#{indent} #{line.strip}\n"
+          end
+        end
+      end
+    end
+
+    def important(message, line_prefix=nil)
+      log(IMPORTANT, message, line_prefix)
+    end
+
+    def info(message, line_prefix=nil)
+      log(INFO, message, line_prefix)
+    end
+
+    def debug(message, line_prefix=nil)
+      log(DEBUG, message, line_prefix)
+    end
+
+    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