capistrano 2.1.0 → 3.0.0

data/lib/capistrano/configuration/loading.rb

@@ -1,198 +0,0 @@
-module Capistrano
-  class Configuration
-    module Loading
-      def self.included(base) #:nodoc:
-        base.send :alias_method, :initialize_without_loading, :initialize
-        base.send :alias_method, :initialize, :initialize_with_loading
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        # Used by third-party task bundles to identify the capistrano
-        # configuration that is loading them. Its return value is not reliable
-        # in other contexts. If +require_config+ is not false, an exception
-        # will be raised if the current configuration is not set.
-        def instance(require_config=false)
-          config = Thread.current[:capistrano_configuration]
-          if require_config && config.nil?
-            raise LoadError, "Please require this file from within a Capistrano recipe"
-          end
-          config
-        end
-
-        # Used internally by Capistrano to specify the current configuration
-        # before loading a third-party task bundle.
-        def instance=(config)
-          Thread.current[:capistrano_configuration] = config
-        end
-
-        # Used internally by Capistrano to track which recipes have been loaded
-        # via require, so that they may be successfully reloaded when require
-        # is called again.
-        def recipes_per_feature
-          @recipes_per_feature ||= {}
-        end
-
-        # Used internally to determine what the current "feature" being
-        # required is. This is used to track which files load which recipes
-        # via require.
-        def current_feature
-          Thread.current[:capistrano_current_feature]
-        end
-
-        # Used internally to specify the current file being required, so that
-        # any recipes loaded by that file can be remembered. This allows
-        # recipes loaded via require to be correctly reloaded in different
-        # Configuration instances in the same Ruby instance.
-        def current_feature=(feature)
-          Thread.current[:capistrano_current_feature] = feature
-        end
-      end
-
-      # The load paths used for locating recipe files.
-      attr_reader :load_paths
-
-      def initialize_with_loading(*args) #:nodoc:
-        initialize_without_loading(*args)
-        @load_paths = [".", File.expand_path(File.join(File.dirname(__FILE__), "../recipes"))]
-        @loaded_features = []
-      end
-      private :initialize_with_loading
-
-      # Load a configuration file or string into this configuration.
-      #
-      # Usage:
-      #
-      #   load("recipe"):
-      #     Look for and load the contents of 'recipe.rb' into this
-      #     configuration.
-      #
-      #   load(:file => "recipe"):
-      #     same as above
-      #
-      #   load(:string => "set :scm, :subversion"):
-      #     Load the given string as a configuration specification.
-      #
-      #   load { ... }
-      #     Load the block in the context of the configuration.
-      def load(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-
-        if block
-          raise ArgumentError, "loading a block requires 0 arguments" unless options.empty? && args.empty?
-          load(:proc => block)
-
-        elsif args.any?
-          args.each { |arg| load options.merge(:file => arg) }
-
-        elsif options[:file]
-          load_from_file(options[:file], options[:name])
-
-        elsif options[:string]
-          remember_load(options) unless options[:reloading]
-          instance_eval(options[:string], options[:name] || "<eval>")
-
-        elsif options[:proc]
-          remember_load(options) unless options[:reloading]
-          instance_eval(&options[:proc])
-
-        else
-          raise ArgumentError, "don't know how to load #{options.inspect}"
-        end
-      end
-
-      # Require another file. This is identical to the standard require method,
-      # with the exception that it sets the receiver as the "current" configuration
-      # so that third-party task bundles can include themselves relative to
-      # that configuration.
-      #
-      # This is a bit more complicated than an initial review would seem to
-      # necessitate, but the use case that complicates things is this: An
-      # advanced user wants to embed capistrano, and needs to instantiate
-      # more than one capistrano configuration at a time. They also want each
-      # configuration to require a third-party capistrano extension. Using a
-      # naive require implementation, this would allow the first configuration
-      # to successfully load the third-party extension, but the require would
-      # fail for the second configuration because the extension has already
-      # been loaded.
-      #
-      # To work around this, we do a few things:
-      #
-      # 1. Each time a 'require' is invoked inside of a capistrano recipe,
-      #    we remember the arguments (see "current_feature").
-      # 2. Each time a 'load' is invoked inside of a capistrano recipe, and
-      #    "current_feature" is not nil (meaning we are inside of a pending
-      #    require) we remember the options (see "remember_load" and
-      #    "recipes_per_feature").
-      # 3. Each time a 'require' is invoked inside of a capistrano recipe,
-      #    we check to see if this particular configuration has ever seen these
-      #    arguments to require (see @loaded_features), and if not, we proceed
-      #    as if the file had never been required. If the superclass' require
-      #    returns false (meaning, potentially, that the file has already been
-      #    required), then we look in the recipes_per_feature collection and
-      #    load any remembered recipes from there.
-      #
-      # It's kind of a bear, but it works, and works transparently. Note that
-      # a simpler implementation would just muck with $", allowing files to be
-      # required multiple times, but that will cause warnings (and possibly
-      # errors) if the file to be required contains constant definitions and
-      # such, alongside (or instead of) capistrano recipe definitions.
-      def require(*args) #:nodoc:
-        # look to see if this specific configuration instance has ever seen
-        # these arguments to require before
-        if !@loaded_features.include?(args)
-          @loaded_features << args
-
-          begin
-            original_instance, self.class.instance = self.class.instance, self
-            original_feature, self.class.current_feature = self.class.current_feature, args
-
-            result = super
-            if !result # file has been required previously, load up the remembered recipes
-              list = self.class.recipes_per_feature[args] || []
-              list.each { |options| load(options.merge(:reloading => true)) }
-            end
-
-            return result
-          ensure
-            # restore the original, so that require's can be nested
-            self.class.instance = original_instance
-            self.class.current_feature = original_feature
-          end
-        else
-          return false
-        end
-      end
-
-      private
-
-        # Load a recipe from the named file. If +name+ is given, the file will
-        # be reported using that name.
-        def load_from_file(file, name=nil)
-          file = find_file_in_load_path(file) unless file[0] == ?/
-          load :string => File.read(file), :name => name || file
-        end
-
-        def find_file_in_load_path(file)
-          load_paths.each do |path|
-            ["", ".rb"].each do |ext|
-              name = File.join(path, "#{file}#{ext}")
-              return name if File.file?(name)
-            end
-          end
-
-          raise LoadError, "no such file to load -- #{file}"
-        end
-
-        # If a file is being required, the options associated with loading a
-        # recipe are remembered in the recipes_per_feature archive under the
-        # name of the file currently being required.
-        def remember_load(options)
-          if self.class.current_feature
-            list = (self.class.recipes_per_feature[self.class.current_feature] ||= [])
-            list << options
-          end
-        end
-    end
-  end
-end

data/lib/capistrano/configuration/namespaces.rb

@@ -1,196 +0,0 @@
-require 'capistrano/task_definition'
-
-module Capistrano
-  class Configuration
-    module Namespaces
-      DEFAULT_TASK = :default
-
-      def self.included(base) #:nodoc:
-        base.send :alias_method, :initialize_without_namespaces, :initialize
-        base.send :alias_method, :initialize, :initialize_with_namespaces
-      end
-
-      # The name of this namespace. Defaults to +nil+ for the top-level
-      # namespace.
-      attr_reader :name
-
-      # The parent namespace of this namespace. Returns +nil+ for the top-level
-      # namespace.
-      attr_reader :parent
-
-      # The hash of tasks defined for this namespace.
-      attr_reader :tasks
-
-      # The hash of namespaces defined for this namespace.
-      attr_reader :namespaces
-
-      def initialize_with_namespaces(*args) #:nodoc:
-        @name = @parent = nil
-        initialize_without_namespaces(*args)
-        @tasks = {}
-        @namespaces = {}
-      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
-        return nil if name.nil?
-        [parent.fully_qualified_name, name].compact.join(":")
-      end
-
-      # Describe the next task to be defined. The given text will be attached to
-      # the next task that is defined and used as its description.
-      def desc(text)
-        @next_description = text
-      end
-
-      # Returns the value set by the last, pending "desc" call. If +reset+ is
-      # not false, the value will be reset immediately afterwards.
-      def next_description(reset=false)
-        @next_description
-      ensure
-        @next_description = nil if reset
-      end
-
-      # Open a namespace in which to define new tasks. If the namespace was
-      # defined previously, it will be reopened, otherwise a new namespace
-      # will be created for the given name.
-      def namespace(name, &block)
-        name = name.to_sym
-        raise ArgumentError, "expected a block" unless block_given?
-
-        namespace_already_defined = namespaces.key?(name)
-        if all_methods.include?(name.to_s) && !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
-
-        namespaces[name] ||= Namespace.new(name, self)
-        namespaces[name].instance_eval(&block)
-
-        # make sure any open description gets terminated
-        namespaces[name].desc(nil)
-
-        if !namespace_already_defined
-          metaclass = class << self; self; end
-          metaclass.send(:define_method, name) { namespaces[name] }
-        end
-      end
-
-      # Describe a new task. If a description is active (see #desc), it is added
-      # to the options under the <tt>:desc</tt> key. The new task is added to
-      # the namespace.
-      def task(name, options={}, &block)
-        name = name.to_sym
-        raise ArgumentError, "expected a block" unless block_given?
-
-        task_already_defined = tasks.key?(name)
-        if all_methods.include?(name.to_s) && !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
-      end
-
-      # Find the task with the given name, where name is the fully-qualified
-      # name of the task. This will search into the namespaces and return
-      # the referenced task, or nil if no such task can be found. If the name
-      # refers to a namespace, the task in that namespace named "default"
-      # will be returned instead, if one exists.
-      def find_task(name)
-        parts = name.to_s.split(/:/)
-        tail = parts.pop.to_sym
-
-        ns = self
-        until parts.empty?
-          ns = ns.namespaces[parts.shift.to_sym]
-          return nil if ns.nil?
-        end
-
-        if ns.namespaces.key?(tail)
-          ns = ns.namespaces[tail]
-          tail = DEFAULT_TASK
-        end
-
-        ns.tasks[tail]
-      end
-
-      # Given a task name, this will search the current namespace, and all
-      # parent namespaces, looking for a task that matches the name, exactly.
-      # It returns the task, if found, or nil, if not.
-      def search_task(name)
-        name = name.to_sym
-        ns = self
-
-        until ns.nil?
-          return ns.tasks[name] if ns.tasks.key?(name)
-          ns = ns.parent
-        end
-
-        return nil
-      end
-
-      # Returns the default task for this namespace. This will be +nil+ if
-      # the namespace is at the top-level, and will otherwise return the
-      # task named "default". If no such task exists, +nil+ will be returned.
-      def default_task
-        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.
-      def task_list(all=false)
-        list = tasks.values
-        namespaces.each { |name,space| list.concat(space.task_list(:all)) } if all
-        list
-      end
-
-      private
-
-        def all_methods
-          public_methods.concat(protected_methods).concat(private_methods)
-        end
-
-        class Namespace
-          def initialize(name, parent)
-            @parent = parent
-            @name = name
-          end
-
-          def role(*args)
-            raise NotImplementedError, "roles cannot be defined in a namespace"
-          end
-
-          def respond_to?(sym)
-            super || parent.respond_to?(sym)
-          end
-
-          def method_missing(sym, *args, &block)
-            if parent.respond_to?(sym)
-              parent.send(sym, *args, &block)
-            else
-              super
-            end
-          end
-
-          include Capistrano::Configuration::Namespaces
-          undef :desc, :next_description
-        end
-    end
-  end
-end

data/lib/capistrano/configuration/roles.rb

@@ -1,51 +0,0 @@
-require 'capistrano/server_definition'
-
-module Capistrano
-  class Configuration
-    module Roles
-      def self.included(base) #:nodoc:
-        base.send :alias_method, :initialize_without_roles, :initialize
-        base.send :alias_method, :initialize, :initialize_with_roles
-      end
-
-      # The hash of roles defined for this configuration. Each entry in the
-      # hash points to an array of server definitions that belong in that
-      # role.
-      attr_reader :roles
-
-      def initialize_with_roles(*args) #:nodoc:
-        initialize_without_roles(*args)
-        @roles = Hash.new { |h,k| h[k] = [] }
-      end
-
-      # Define a new role and its associated servers. You must specify at least
-      # one host for each role. 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 role definition.
-      #
-      # Usage:
-      #
-      #   role :db,  "db1.example.com", "db2.example.com"
-      #   role :db,  "master.example.com", :primary => true
-      #   role :app, "app1.example.com", "app2.example.com"
-      #
-      # You can also encode the username and port number for each host in the
-      # server string, if needed:
-      #
-      #   role :web,  "www@web1.example.com"
-      #   role :file, "files.example.com:4144"
-      #   role :db,   "admin@db3.example.com:1234"
-      #
-      # Lastly, username and port number may be passed as options, if that is
-      # preferred; note that the options apply to all servers defined in
-      # that call to "role":
-      #
-      #   role :web, "web2", "web3", :user => "www", :port => 2345
-      def role(which, *args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        which = which.to_sym
-        args.each { |host| roles[which] << ServerDefinition.new(host, options) }
-      end
-    end
-  end
-end

data/lib/capistrano/configuration/variables.rb

@@ -1,127 +0,0 @@
-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) #:nodoc:
-        @variables.has_key?(sym) || respond_to_without_variables?(sym)
-      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

@@ -1,15 +0,0 @@
-module Capistrano
-  class Error < RuntimeError; end
-
-  class CaptureError < Error; end
-  class NoSuchTaskError < Error; end
-  class NoMatchingServersError < Error; end
-  
-  class RemoteError < Error
-    attr_accessor :hosts
-  end
-
-  class ConnectionError < RemoteError; end
-  class UploadError < RemoteError; end
-  class CommandError < RemoteError; end
-end

data/lib/capistrano/extensions.rb

@@ -1,57 +0,0 @@
-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.include?(name.to_s)
-      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