engineyard 2.0.0.pre1 → 2.0.0.pre2

data/lib/vendor/thor/lib/thor/invocation.rb

@@ -1,170 +0,0 @@
-class Thor
-  module Invocation
-    def self.included(base) #:nodoc:
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # This method is responsible for receiving a name and find the proper
-      # class and task for it. The key is an optional parameter which is
-      # available only in class methods invocations (i.e. in Thor::Group).
-      def prepare_for_invocation(key, name) #:nodoc:
-        case name
-        when Symbol, String
-          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
-        else
-          name
-        end
-      end
-    end
-
-    # Make initializer aware of invocations and the initialization args.
-    def initialize(args=[], options={}, config={}, &block) #:nodoc:
-      @_invocations = config[:invocations] || Hash.new { |h,k| h[k] = [] }
-      @_initializer = [ args, options, config ]
-      super
-    end
-
-    # Receives a name and invokes it. The name can be a string (either "task" or
-    # "namespace:task"), a Thor::Task, a Class or a Thor instance. If the task
-    # cannot be guessed by name, it can also be supplied as second argument.
-    #
-    # You can also supply the arguments, options and configuration values for
-    # the task to be invoked, if none is given, the same values used to
-    # initialize the invoker are used to initialize the invoked.
-    #
-    # When no name is given, it will invoke the default task of the current class.
-    #
-    # ==== Examples
-    #
-    #   class A < Thor
-    #     def foo
-    #       invoke :bar
-    #       invoke "b:hello", ["José"]
-    #     end
-    #
-    #     def bar
-    #       invoke "b:hello", ["José"]
-    #     end
-    #   end
-    #
-    #   class B < Thor
-    #     def hello(name)
-    #       puts "hello #{name}"
-    #     end
-    #   end
-    #
-    # You can notice that the method "foo" above invokes two tasks: "bar",
-    # which belongs to the same class and "hello" which belongs to the class B.
-    #
-    # By using an invocation system you ensure that a task is invoked only once.
-    # In the example above, invoking "foo" will invoke "b:hello" just once, even
-    # if it's invoked later by "bar" method.
-    #
-    # When class A invokes class B, all arguments used on A initialization are
-    # supplied to B. This allows lazy parse of options. Let's suppose you have
-    # some rspec tasks:
-    #
-    #   class Rspec < Thor::Group
-    #     class_option :mock_framework, :type => :string, :default => :rr
-    #
-    #     def invoke_mock_framework
-    #       invoke "rspec:#{options[:mock_framework]}"
-    #     end
-    #   end
-    #
-    # As you noticed, it invokes the given mock framework, which might have its
-    # own options:
-    #
-    #   class Rspec::RR < Thor::Group
-    #     class_option :style, :type => :string, :default => :mock
-    #   end
-    #
-    # Since it's not rspec concern to parse mock framework options, when RR
-    # is invoked all options are parsed again, so RR can extract only the options
-    # that it's going to use.
-    #
-    # If you want Rspec::RR to be initialized with its own set of options, you
-    # have to do that explicitly:
-    #
-    #   invoke "rspec:rr", [], :style => :foo
-    #
-    # Besides giving an instance, you can also give a class to invoke:
-    #
-    #   invoke Rspec::RR, [], :style => :foo
-    #
-    def invoke(name=nil, *args)
-      if name.nil?
-        warn "[Thor] Calling invoke() without argument is deprecated. Please use invoke_all instead.\n#{caller.join("\n")}"
-        return invoke_all
-      end
-
-      args.unshift(nil) if Array === args.first || NilClass === args.first
-      task, args, opts, config = args
-
-      klass, task = _retrieve_class_and_task(name, task)
-      raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
-
-      args, opts, config = _parse_initialization_options(args, opts, config)
-      klass.send(:dispatch, task, args, opts, config) do |instance|
-        instance.parent_options = options
-      end
-    end
-
-    # Invoke the given task if the given args.
-    def invoke_task(task, *args) #:nodoc:
-      current = @_invocations[self.class]
-
-      unless current.include?(task.name)
-        current << task.name
-        task.run(self, *args)
-      end
-    end
-
-    # Invoke all tasks for the current instance.
-    def invoke_all #:nodoc:
-      self.class.all_tasks.map { |_, task| invoke_task(task) }
-    end
-
-    # Invokes using shell padding.
-    def invoke_with_padding(*args)
-      with_padding { invoke(*args) }
-    end
-
-    protected
-
-      # Configuration values that are shared between invocations.
-      def _shared_configuration #:nodoc:
-        { :invocations => @_invocations }
-      end
-
-      # This method simply retrieves the class and task to be invoked.
-      # If the name is nil or the given name is a task in the current class,
-      # use the given name and return self as class. Otherwise, call
-      # prepare_for_invocation in the current class.
-      def _retrieve_class_and_task(name, sent_task=nil) #:nodoc:
-        case
-        when name.nil?
-          [self.class, nil]
-        when self.class.all_tasks[name.to_s]
-          [self.class, name.to_s]
-        else
-          klass, task = self.class.prepare_for_invocation(nil, name)
-          [klass, task || sent_task]
-        end
-      end
-
-      # Initialize klass using values stored in the @_initializer.
-      def _parse_initialization_options(args, opts, config) #:nodoc:
-        stored_args, stored_opts, stored_config = @_initializer
-
-        args ||= stored_args.dup
-        opts ||= stored_opts.dup
-
-        config ||= {}
-        config = stored_config.merge(_shared_configuration).merge!(config)
-
-        [ args, opts, config ]
-      end
-  end
-end

data/lib/vendor/thor/lib/thor/parser.rb

@@ -1,4 +0,0 @@
-require 'thor/parser/argument'
-require 'thor/parser/arguments'
-require 'thor/parser/option'
-require 'thor/parser/options'

data/lib/vendor/thor/lib/thor/parser/argument.rb

@@ -1,67 +0,0 @@
-class Thor
-  class Argument #:nodoc:
-    VALID_TYPES = [ :numeric, :hash, :array, :string ]
-
-    attr_reader :name, :description, :required, :type, :default, :banner
-    alias :human_name :name
-
-    def initialize(name, description=nil, required=true, type=:string, default=nil, banner=nil)
-      class_name = self.class.name.split("::").last
-
-      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
-      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
-
-      @name        = name.to_s
-      @description = description
-      @required    = required || false
-      @type        = (type || :string).to_sym
-      @default     = default
-      @banner      = banner || default_banner
-
-      validate! # Trigger specific validations
-    end
-
-    def usage
-      required? ? banner : "[#{banner}]"
-    end
-
-    def required?
-      required
-    end
-
-    def show_default?
-      case default
-      when Array, String, Hash
-        !default.empty?
-      else
-        default
-      end
-    end
-
-    protected
-
-      def validate!
-        raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
-      end
-
-      def valid_type?(type)
-        self.class::VALID_TYPES.include?(type.to_sym)
-      end
-
-      def default_banner
-        case type
-        when :boolean
-          nil
-        when :string, :default
-          human_name.upcase
-        when :numeric
-          "N"
-        when :hash
-          "key:value"
-        when :array
-          "one two three"
-        end
-      end
-
-  end
-end

data/lib/vendor/thor/lib/thor/parser/arguments.rb

@@ -1,165 +0,0 @@
-class Thor
-  class Arguments #:nodoc:
-    NUMERIC = /(\d*\.\d+|\d+)/
-
-    # Receives an array of args and returns two arrays, one with arguments
-    # and one with switches.
-    #
-    def self.split(args)
-      arguments = []
-
-      args.each do |item|
-        break if item =~ /^-/
-        arguments << item
-      end
-
-      return arguments, args[Range.new(arguments.size, -1)]
-    end
-
-    def self.parse(*args)
-      to_parse = args.pop
-      new(*args).parse(to_parse)
-    end
-
-    # Takes an array of Thor::Argument objects.
-    #
-    def initialize(arguments=[])
-      @assigns, @non_assigned_required = {}, []
-      @switches = arguments
-
-      arguments.each do |argument|
-        if argument.default != nil
-          @assigns[argument.human_name] = argument.default
-        elsif argument.required?
-          @non_assigned_required << argument
-        end
-      end
-    end
-
-    def parse(args)
-      @pile = args.dup
-
-      @switches.each do |argument|
-        break unless peek
-        @non_assigned_required.delete(argument)
-        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
-      end
-
-      check_requirement!
-      @assigns
-    end
-
-    def remaining
-      @pile
-    end
-
-    private
-
-      def no_or_skip?(arg)
-        arg =~ /^--(no|skip)-([-\w]+)$/
-        $2
-      end
-
-      def last?
-        @pile.empty?
-      end
-
-      def peek
-        @pile.first
-      end
-
-      def shift
-        @pile.shift
-      end
-
-      def unshift(arg)
-        unless arg.kind_of?(Array)
-          @pile.unshift(arg)
-        else
-          @pile = arg + @pile
-        end
-      end
-
-      def current_is_value?
-        peek && peek.to_s !~ /^-/
-      end
-
-      # Runs through the argument array getting strings that contains ":" and
-      # mark it as a hash:
-      #
-      #   [ "name:string", "age:integer" ]
-      #
-      # Becomes:
-      #
-      #   { "name" => "string", "age" => "integer" }
-      #
-      def parse_hash(name)
-        return shift if peek.is_a?(Hash)
-        hash = {}
-
-        while current_is_value? && peek.include?(?:)
-          key, value = shift.split(':',2)
-          hash[key] = value
-        end
-        hash
-      end
-
-      # Runs through the argument array getting all strings until no string is
-      # found or a switch is found.
-      #
-      #   ["a", "b", "c"]
-      #
-      # And returns it as an array:
-      #
-      #   ["a", "b", "c"]
-      #
-      def parse_array(name)
-        return shift if peek.is_a?(Array)
-        array = []
-
-        while current_is_value?
-          array << shift
-        end
-        array
-      end
-
-      # Check if the peek is numeric format and return a Float or Integer.
-      # Otherwise raises an error.
-      #
-      def parse_numeric(name)
-        return shift if peek.is_a?(Numeric)
-
-        unless peek =~ NUMERIC && $& == peek
-          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
-        end
-
-        $&.index('.') ? shift.to_f : shift.to_i
-      end
-
-      # Parse string:
-      # for --string-arg, just return the current value in the pile
-      # for --no-string-arg, nil
-      #
-      def parse_string(name)
-        if no_or_skip?(name)
-          nil
-        else
-          shift
-        end
-      end
-
-      # Raises an error if @non_assigned_required array is not empty.
-      #
-      def check_requirement!
-        unless @non_assigned_required.empty?
-          names = @non_assigned_required.map do |o|
-            o.respond_to?(:switch_name) ? o.switch_name : o.human_name
-          end.join("', '")
-
-          class_name = self.class.name.split('::').last.downcase
-          raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
-        end
-      end
-
-  end
-end

data/lib/vendor/thor/lib/thor/parser/option.rb

@@ -1,121 +0,0 @@
-class Thor
-  class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default, :hide
-
-    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
-
-    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, lazy_default=nil, group=nil, aliases=nil, hide=nil)
-      super(name, description, required, type, default, banner)
-      @lazy_default = lazy_default
-      @group        = group.to_s.capitalize if group
-      @aliases      = [*aliases].compact
-      @hide         = hide
-    end
-
-    # This parse quick options given as method_options. It makes several
-    # assumptions, but you can be more specific using the option method.
-    #
-    #   parse :foo => "bar"
-    #   #=> Option foo with default value bar
-    #
-    #   parse [:foo, :baz] => "bar"
-    #   #=> Option foo with default value bar and alias :baz
-    #
-    #   parse :foo => :required
-    #   #=> Required option foo without default value
-    #
-    #   parse :foo => 2
-    #   #=> Option foo with default value 2 and type numeric
-    #
-    #   parse :foo => :numeric
-    #   #=> Option foo without default value and type numeric
-    #
-    #   parse :foo => true
-    #   #=> Option foo with default value true and type boolean
-    #
-    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
-    # is given a default type is assumed. This default type accepts arguments as
-    # string (--foo=value) or booleans (just --foo).
-    #
-    # By default all options are optional, unless :required is given.
-    #
-    def self.parse(key, value)
-      if key.is_a?(Array)
-        name, *aliases = key
-      else
-        name, aliases = key, []
-      end
-
-      name    = name.to_s
-      default = value
-
-      type = case value
-      when Symbol
-        default = nil
-        if VALID_TYPES.include?(value)
-          value
-        elsif required = (value == :required)
-          :string
-        end
-      when TrueClass, FalseClass
-        :boolean
-      when Numeric
-        :numeric
-      when Hash, Array, String
-        value.class.name.downcase.to_sym
-      end
-
-      self.new(name.to_s, nil, required, type, default, nil, nil, nil, aliases)
-    end
-
-    def switch_name
-      @switch_name ||= dasherized? ? name : dasherize(name)
-    end
-
-    def human_name
-      @human_name ||= dasherized? ? undasherize(name) : name
-    end
-
-    def usage(padding=0)
-      sample = if banner && !banner.to_s.empty?
-        "#{switch_name}=#{banner}"
-      else
-        switch_name
-      end
-
-      sample = "[#{sample}]" unless required?
-
-      if aliases.empty?
-        (" " * padding) << sample
-      else
-        "#{aliases.join(', ')}, #{sample}"
-      end
-    end
-
-    VALID_TYPES.each do |type|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{type}?
-          self.type == #{type.inspect}
-        end
-      RUBY
-    end
-
-  protected
-
-    def validate!
-      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
-    end
-
-    def dasherized?
-      name.index('-') == 0
-    end
-
-    def undasherize(str)
-      str.sub(/^-{1,2}/, '')
-    end
-
-    def dasherize(str)
-      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
-    end
-  end
-end