engineyard-serverside 2.0.0 → 2.0.1

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

@@ -10,10 +10,10 @@ class Thor
       # 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)
-          else
-            name
+        when Symbol, String
+          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+        else
+          name
         end
       end
     end
@@ -85,7 +85,7 @@ class Thor
     # 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 explicitely:
+    # have to do that explicitly:
     #
     #   invoke "rspec:rr", [], :style => :foo
     #
@@ -94,31 +94,38 @@ class Thor
     #   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
 
-      object, task    = _prepare_for_invocation(name, task)
-      klass, instance = _initialize_klass_with_initializer(object, args, opts, config)
-
-      method_args = []
-      current = @_invocations[klass]
+      klass, task = _retrieve_class_and_task(name, task)
+      raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
 
-      iterator = proc do |_, task|
-        unless current.include?(task.name)
-          current << task.name
-          task.run(instance, method_args)
-        end
+      args, opts, config = _parse_initialization_options(args, opts, config)
+      klass.send(:dispatch, task, args, opts, config) do |instance|
+        instance.parent_options = options
       end
+    end
 
-      if task
-        args ||= []
-        method_args = args[Range.new(klass.arguments.size, -1)] || []
-        iterator.call(nil, task)
-      else
-        klass.all_tasks.map(&iterator)
+    # 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) }
@@ -131,50 +138,33 @@ class Thor
         { :invocations => @_invocations }
       end
 
-      # This method can receive several different types of arguments and it's then
-      # responsible to normalize them by returning the object where the task should
-      # be invoked and a Thor::Task object.
-      def _prepare_for_invocation(name, sent_task=nil) #:nodoc:
-        if name.is_a?(Thor::Task)
-          task = name
-        elsif task = self.class.all_tasks[name.to_s]
-          object = self
+      # 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
-          object, task = self.class.prepare_for_invocation(nil, name)
-          task ||= sent_task
+          klass, task = self.class.prepare_for_invocation(nil, name)
+          [klass, task || sent_task]
         end
-
-        # If the object was not set, use self and use the name as task.
-        object, task = self, name unless object
-        return object, _validate_task(object, task)
-      end
-
-      # Check if the object given is a Thor class object and get a task object
-      # for it.
-      def _validate_task(object, task) #:nodoc:
-        klass = object.is_a?(Class) ? object : object.class
-        raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
-
-        task ||= klass.default_task if klass.respond_to?(:default_task)
-        task = klass.all_tasks[task.to_s] || Thor::Task::Dynamic.new(task) if task && !task.is_a?(Thor::Task)
-        task
       end
 
       # Initialize klass using values stored in the @_initializer.
-      def _initialize_klass_with_initializer(object, args, opts, config) #:nodoc:
-        if object.is_a?(Class)
-          klass = object
+      def _parse_initialization_options(args, opts, config) #:nodoc:
+        stored_args, stored_opts, stored_config = @_initializer
 
-          stored_args, stored_opts, stored_config = @_initializer
-          args ||= stored_args.dup
-          opts ||= stored_opts.dup
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
 
-          config ||= {}
-          config = stored_config.merge(_shared_configuration).merge!(config)
-          [ klass, klass.new(args, opts, config) ]
-        else
-          [ object.class, object ]
-        end
+        config ||= {}
+        config = stored_config.merge(_shared_configuration).merge!(config)
+
+        [ args, opts, config ]
       end
   end
 end

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

@@ -2,21 +2,24 @@ class Thor
   class Argument #:nodoc:
     VALID_TYPES = [ :numeric, :hash, :array, :string ]
 
-    attr_reader :name, :description, :required, :type, :default, :banner
+    attr_reader :name, :description, :enum, :required, :type, :default, :banner
     alias :human_name :name
 
-    def initialize(name, description=nil, required=true, type=:string, default=nil, banner=nil)
+    def initialize(name, options={})
       class_name = self.class.name.split("::").last
 
+      type = options[:type]
+
       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
+      @description = options[:desc]
+      @required    = options.key?(:required) ? options[:required] : true
       @type        = (type || :string).to_sym
-      @default     = default
-      @banner      = banner || default_banner
+      @default     = options[:default]
+      @banner      = options[:banner] || default_banner
+      @enum        = options[:enum]
 
       validate! # Trigger specific validations
     end
@@ -31,35 +34,39 @@ class Thor
 
     def show_default?
       case default
-        when Array, String, Hash
-          !default.empty?
-        else
-          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?
+        if required? && !default.nil?
+          raise ArgumentError, "An argument cannot be required and have default value."
+        elsif @enum && !@enum.is_a?(Array)
+          raise ArgumentError, "An argument cannot have an enum other than an array."
+        end
       end
 
       def valid_type?(type)
-        VALID_TYPES.include?(type.to_sym)
+        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"
+        when :boolean
+          nil
+        when :string, :default
+          human_name.upcase
+        when :numeric
+          "N"
+        when :hash
+          "key:value"
+        when :array
+          "one two three"
         end
       end
 

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

@@ -28,7 +28,7 @@ class Thor
       @switches = arguments
 
       arguments.each do |argument|
-        if argument.default
+        if argument.default != nil
           @assigns[argument.human_name] = argument.default
         elsif argument.required?
           @non_assigned_required << argument
@@ -49,8 +49,17 @@ class Thor
       @assigns
     end
 
+    def remaining
+      @pile
+    end
+
     private
 
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
       def last?
         @pile.empty?
       end
@@ -89,7 +98,7 @@ class Thor
         hash = {}
 
         while current_is_value? && peek.include?(?:)
-          key, value = shift.split(':')
+          key, value = shift.split(':',2)
           hash[key] = value
         end
         hash
@@ -114,7 +123,7 @@ class Thor
         array
       end
 
-      # Check if the peel is numeric ofrmat and return a Float or Integer.
+      # Check if the peek is numeric format and return a Float or Integer.
       # Otherwise raises an error.
       #
       def parse_numeric(name)
@@ -127,10 +136,22 @@ class Thor
         $&.index('.') ? shift.to_f : shift.to_i
       end
 
-      # Parse string, i.e., just return the current value in the pile.
+      # Parse string:
+      # for --string-arg, just return the current value in the pile
+      # for --no-string-arg, nil
       #
       def parse_string(name)
-        shift
+        if no_or_skip?(name)
+          nil
+        else
+          value = shift
+          if @switches.is_a?(Hash) && switch = @switches[name]
+            if switch.enum && !switch.enum.include?(value)
+              raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+            end
+          end
+          value
+        end
       end
 
       # Raises an error if @non_assigned_required array is not empty.

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

@@ -1,13 +1,16 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group
+    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, group=nil, aliases=nil)
-      super(name, description, required, type, default, banner)
-      @aliases = [*aliases].compact
-      @group   = group.to_s.capitalize if group
+    def initialize(name, options={})
+      options[:required] = false unless options.key?(:required)
+      super
+      @lazy_default = options[:lazy_default]
+      @group        = options[:group].to_s.capitalize if options[:group]
+      @aliases      = Array(options[:aliases])
+      @hide         = options[:hide]
     end
 
     # This parse quick options given as method_options. It makes several
@@ -36,7 +39,7 @@ class Thor
     # 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
@@ -48,23 +51,21 @@ class Thor
       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
+      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, aliases)
+      self.new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
     end
 
     def switch_name
@@ -91,38 +92,30 @@ class Thor
       end
     end
 
-    # Allow some type predicates as: boolean?, string? and etc.
-    #
-    def method_missing(method, *args, &block)
-      given = method.to_s.sub(/\?$/, '').to_sym
-      if valid_type?(given)
-        self.type == given
-      else
-        super
-      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 valid_type?(type)
-        VALID_TYPES.include?(type.to_sym)
-      end
+  protected
 
-      def dasherized?
-        name.index('-') == 0
-      end
+    def validate!
+      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+    end
 
-      def undasherize(str)
-        str.sub(/^-{1,2}/, '')
-      end
+    def dasherized?
+      name.index('-') == 0
+    end
 
-      def dasherize(str)
-        (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
-      end
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
 
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+    end
   end
 end

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

@@ -1,7 +1,4 @@
 class Thor
-  # This is a modified version of Daniel Berger's Getopt::Long class, licensed
-  # under Ruby's license.
-  #
   class Options < Arguments #:nodoc:
     LONG_RE     = /^(--\w+(?:-\w+)*)$/
     SHORT_RE    = /^(-[a-z])$/i
@@ -38,7 +35,7 @@ class Thor
         @non_assigned_required.delete(hash_options[key])
       end
 
-      @shorts, @switches, @unknown = {}, {}, []
+      @shorts, @switches, @extra = {}, {}, []
 
       options.each do |option|
         @switches[option.switch_name] = option
@@ -49,12 +46,19 @@ class Thor
       end
     end
 
+    def remaining
+      @extra
+    end
+
     def parse(args)
       @pile = args.dup
 
       while peek
-        if current_is_switch?
-          case shift
+        match, is_switch = current_is_switch?
+        shifted = shift
+
+        if is_switch
+          case shifted
             when SHORT_SQ_RE
               unshift($1.split('').map { |f| "-#{f}" })
               next
@@ -68,10 +72,11 @@ class Thor
           switch = normalize_switch(switch)
           option = switch_option(switch)
           @assigns[option.human_name] = parse_peek(switch, option)
-        elsif current_is_switch_formatted?
-          @unknown << shift
+        elsif match
+          @extra << shifted
+          @extra << shift while peek && peek !~ /^-/
         else
-          shift
+          @extra << shifted
         end
       end
 
@@ -83,7 +88,9 @@ class Thor
     end
 
     def check_unknown!
-      raise UnknownArgumentError, "Unknown switches '#{@unknown.join(', ')}'" unless @unknown.empty?
+      # an unknown option starts with - or -- and has no more --'s afterward.
+      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
+      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
     end
 
     protected
@@ -92,15 +99,17 @@ class Thor
       #
       def current_is_switch?
         case peek
-          when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-            switch?($1)
-          when SHORT_SQ_RE
-            $1.split('').any? { |f| switch?("-#{f}") }
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+          [true, switch?($1)]
+        when SHORT_SQ_RE
+          [true, $1.split('').any? { |f| switch?("-#{f}") }]
+        else
+          [false, false]
         end
       end
 
-      def switch_formatted?(arg)
-        case arg
+      def current_is_switch_formatted?
+        case peek
         when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
           true
         else
@@ -108,12 +117,8 @@ class Thor
         end
       end
 
-      def current_is_switch_formatted?
-        switch_formatted? peek
-      end
-
       def switch?(arg)
-        switch_option(arg) || @shorts.key?(arg)
+        switch_option(normalize_switch(arg))
       end
 
       def switch_option(arg)
@@ -124,22 +129,25 @@ class Thor
         end
       end
 
-      def no_or_skip?(arg)
-        arg =~ /^--(no|skip)-([-\w]+)$/
-        $2
-      end
-
       # Check if the given argument is actually a shortcut.
       #
       def normalize_switch(arg)
-        @shorts.key?(arg) ? @shorts[arg] : arg
+        (@shorts[arg] || arg).tr('_', '-')
       end
 
       # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
       #
       def parse_boolean(switch)
         if current_is_value?
-          ["true", "TRUE", "t", "T", true].include?(shift)
+          if ["true", "TRUE", "t", "T", true].include?(peek)
+            shift
+            true
+          elsif ["false", "FALSE", "f", "F", false].include?(peek)
+            shift
+            false
+          else
+            true
+          end
         else
           @switches.key?(switch) || !no_or_skip?(switch)
         end
@@ -155,7 +163,9 @@ class Thor
             return nil # User set value to nil
           elsif option.string? && !option.required?
             # Return the default if there is one, else the human name
-            return option.default || option.human_name
+            return option.lazy_default || option.default || option.human_name
+          elsif option.lazy_default
+            return option.lazy_default
           else
             raise MalformattedArgumentError, "No value provided for option '#{switch}'"
           end
@@ -164,6 +174,5 @@ class Thor
         @non_assigned_required.delete(option)
         send(:"parse_#{option.type}", switch)
       end
-
   end
 end