josevalim-thor 0.10.18 → 0.10.19

data/lib/thor/actions.rb

@@ -52,8 +52,10 @@ class Thor
           :invoke
       end
 
-      super
       self.root = config[:root]
+      config[:root] = self.root # Cache in the config hash to be shared
+
+      super
     end
 
     # Wraps an action object and call it accordingly to the thor class behavior.
@@ -298,12 +300,6 @@ class Thor
 
     protected
 
-      # Allow current root to be sent as configuration value to the invoked class.
-      #
-      def _overrides_config #:nodoc:
-        super.merge!(:root => self.root)
-      end
-
       def _cleanup_options_and_set(options, key)
         [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
         options.merge!(key => true)

data/lib/thor/base.rb

@@ -3,7 +3,7 @@ require 'thor/core_ext/ordered_hash'
 require 'thor/error'
 require 'thor/shell'
 require 'thor/invocation'
-require 'thor/options'
+require 'thor/parser'
 require 'thor/task'
 require 'thor/util'
 
@@ -31,15 +31,40 @@ class Thor
     # config<Hash>:: Configuration for this Thor class.
     #
     def initialize(args=[], options={}, config={})
-      # Set arguments and default values
-      self.class.arguments.zip(args).each do |argument, value|
-        send("#{argument.human_name}=", value || argument.default)
+      Thor::Arguments.parse(self.class.arguments, args).each do |key, value|
+        send("#{key}=", value)
       end
 
-      self.class.merge_with_thor_options(options, self.class.class_options)
+      if options.is_a?(Array)
+        task_options  = config.delete(:task_options)
+        parse_options = self.class.class_options
+        parse_options = parse_options.merge(task_options) if task_options
+
+        options = Thor::Options.parse(parse_options, options)
+        _set_default_options(options, task_options) if task_options
+      end
+
+      _set_default_options(options, self.class.class_options)
       self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).freeze
     end
 
+    protected
+
+      # Receives a hash of options, stringify keys and merge with default
+      # values from thor options.
+      #
+      def _set_default_options(options, default_options)
+        options.each_key do |key|
+          next unless key.is_a?(Symbol)
+          options[key.to_s] = options.delete(key)
+        end
+
+        default_options.each do |key, option|
+          next if option.default.nil? || options.key?(option.human_name.to_s)
+          options[option.human_name.to_s] ||= option.default
+        end
+      end
+
     class << self
       def included(base) #:nodoc:
         base.send :extend,  ClassMethods
@@ -130,14 +155,16 @@ class Thor
           options[:default].nil?
         end
 
-        class_options.values.each do |option|
-          next unless option.argument? && !option.required?
+        remove_argument name
+
+        arguments.each do |argument|
+          next if argument.required?
           raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
-                               "the non-required argument #{option.human_name.inspect}."
+                               "the non-required argument #{argument.human_name.inspect}."
         end if required
 
-        class_options[name] = Thor::Argument.new(name, options[:desc], required, options[:type],
-                                                       options[:default], options[:banner])
+        arguments << Thor::Argument.new(name, options[:desc], required, options[:type],
+                                              options[:default], options[:banner])
       end
 
       # Returns this class arguments, looking up in the ancestors chain.
@@ -146,7 +173,7 @@ class Thor
       # Array[Thor::Argument]
       #
       def arguments
-        class_options.values.select{ |o| o.argument? }
+        @arguments ||= from_superclass(:arguments, [])
       end
 
       # Adds a bunch of options to the set of class options.
@@ -159,7 +186,7 @@ class Thor
       # Hash[Symbol => Object]
       #
       def class_options(options=nil)
-        @class_options ||= from_superclass(:class_options, Thor::CoreExt::OrderedHash.new)
+        @class_options ||= from_superclass(:class_options, {})
         build_options(options, @class_options) if options
         @class_options
       end
@@ -199,7 +226,7 @@ class Thor
         options = names.last.is_a?(Hash) ? names.pop : {}
 
         names.each do |name|
-          class_options.delete(name)
+          arguments.delete_if { |a| a.name == name.to_s }
           undef_method name, "#{name}=" if options[:undefine]
         end
       end
@@ -332,41 +359,6 @@ class Thor
         end
       end
 
-      # Parses the task and options from the given args, instantiate the class
-      # and invoke the task. This method is used when the arguments must be parsed
-      # from an array. If you are inside Ruby and want to use a Thor class, you
-      # can simply initialize it:
-      #
-      #   script = MyScript.new(args, options, config)
-      #   script.invoke(:task, first_arg, second_arg, third_arg)
-      #
-      def start(args=ARGV, config={})
-        config[:shell] ||= Thor::Base.shell.new
-
-        task = normalize_arguments(args, config)
-        return unless task
-
-        instance, trailing = prepare(task, args, config)
-        instance.invoke(task, trailing)
-      rescue Thor::Error => e
-        config[:shell].error e.message
-      end
-
-      # Receives a hash of options, stringify keys and merge with default
-      # values from thor options.
-      #
-      def merge_with_thor_options(options, thor_options)
-        options.each_key do |key|
-          next unless key.is_a?(Symbol)
-          options[key.to_s] = options.delete(key)
-        end
-
-        thor_options.each do |key, option|
-          next if option.argument? || option.default.nil? || options.key?(option.human_name.to_s)
-          options[option.human_name.to_s] ||= option.default
-        end
-      end
-
       protected
 
         # Prints the class options per group. If an option does not belong to
@@ -380,13 +372,17 @@ class Thor
         #
         def class_options_help(shell, ungrouped_name=nil, extra_group=nil) #:nodoc:
           unless self.class_options.empty?
-            groups = self.class_options.group_values_by { |o| o.group }
+            groups = {}
+
+            class_options.each do |_, value|
+              groups[value.group] ||= []
+              groups[value.group] << value
+            end
 
             printer = lambda do |group_name, options|
               list = []
 
               options.each do |option|
-                next if option.argument?
                 list << [ option.usage, option.description || "" ]
                 list << [ "", "Default: #{option.default}" ] if option.show_default?
               end
@@ -516,18 +512,6 @@ class Thor
         # class.
         def initialize_added #:nodoc:
         end
-
-        # SIGNATURE: Normalize arguments when invoked through start. Should
-        # return the name of the task to be invoked. Returning nil makes the
-        # start process to exist without error message.
-        def normalize_arguments(args, config) #:nodoc:
-        end
-
-        # SIGNATURE: Receives a task, arguments to be parsed and configuration
-        # values and initializes the current class. Trailing arguments are
-        # returned to be sent to the invoked task.
-        def prepare(task, args, config) #:nodoc:
-        end
     end
   end
 end

data/lib/thor/core_ext/ordered_hash.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 class Thor #:nodoc:
   module CoreExt #:nodoc:
 
@@ -15,40 +17,13 @@ class Thor #:nodoc:
         @hash = {}
       end
 
-      # Called on clone. It gets all the notes from the cloned object, dup them
-      # and assign the duped objects siblings.
-      #
-      def initialize_copy(other)
-        @hash = {}
-
-        array = []
-        other.each do |key, value|
-          array << (@hash[key] = Node.new(key, value))
-        end
-
-        array.each_with_index do |node, i|
-          node.next = array[i + 1]
-          node.prev = array[i - 1] if i > 0
-        end
-
-        @first = array.first
-        @last  = array.last
-      end
-
       def [](key)
         @hash[key] && @hash[key].value
       end
 
       def []=(key, value)
-        if old = @hash[key]
-          node = old.dup
+        if node = @hash[key]
           node.value = value
-
-          @first = node if @first == old
-          @last  = node if @last  == old
-
-          old.prev.next = node if old.prev
-          old.next.prev = node if old.next
         else
           node = Node.new(key, value)
 
@@ -79,7 +54,7 @@ class Thor #:nodoc:
           value = node.value
         end
 
-        @hash[key] = nil
+        @hash.delete(key)
         value
       end
 
@@ -99,41 +74,23 @@ class Thor #:nodoc:
         self
       end
 
-      def group_values_by
-        assoc = self.class.new
-        each do |_, element|
-          key = yield(element)
-          assoc[key] ||= []
-          assoc[key] << element
-        end
-        assoc
-      end
-
       def merge(other)
-        dup.merge!(other)
-      end
+        hash = self.class.new
+
+        self.each do |key, value|
+          hash[key] = value
+        end
 
-      def merge!(other)
         other.each do |key, value|
-          self[key] = value
+          hash[key] = value
         end
-        self
+
+        hash
       end
 
       def empty?
         @hash.empty?
       end
-
-      def to_a
-        array = []
-        each { |k, v| array << [k, v] }
-        array
-      end
-
-      def to_s
-        to_a.inspect
-      end
-      alias :inspect :to_s
     end
   end
 end

data/lib/thor/group.rb

@@ -18,17 +18,21 @@ class Thor::Group
       end
     end
 
-    # Implements the prepare interface being used by start.
+    # Start works differently in Thor::Group, it simply invokes all tasks
+    # inside the class.
     #
-    def prepare(task, args, config) #:nodoc:
-      opts = Thor::Options.new(class_options)
-      opts.parse(args)
+    def start(given_args=ARGV, config={})
+      config[:shell] ||= Thor::Base.shell.new
 
-      instance = new(opts.arguments, opts.options, config) do |klass, invoke, overrides|
-        klass.prepare(invoke, args, config.merge(overrides))
+      if Thor::HELP_MAPPINGS.include?(given_args.first)
+        help(config[:shell])
+        return
       end
 
-      return instance, nil
+      args, opts = Thor::Options.split(given_args)
+      new(args, opts, config).invoke
+    rescue Thor::Error => e
+      config[:shell].error e.message
     end
 
     # Prints help information.
@@ -54,7 +58,7 @@ class Thor::Group
       # thor class by another means which is not the Thor::Runner.
       #
       def banner #:nodoc:
-        "#{self.namespace} #{self.arguments.map {|o| o.usage }.join(' ')}"
+        "#{self.namespace} #{self.arguments.map {|a| a.usage }.join(' ')}"
       end
 
       def baseclass #:nodoc:
@@ -68,26 +72,7 @@ class Thor::Group
       def create_task(meth) #:nodoc:
         tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil)
       end
-
-      def normalize_arguments(args, config) #:nodoc:
-        if Thor::HELP_MAPPINGS.include?(args.first)
-          help(config[:shell])
-          nil
-        else
-          :all
-        end
-      end
   end
 
   include Thor::Base
-
-  protected
-
-    # Overwrite _setup_for_invoke to force invocation of all tasks when :all is
-    # supplied.
-    #
-    def _setup_for_invoke(object, task=nil)
-      super(object.to_s == "all" ? nil : object)
-    end
-
 end

data/lib/thor/invocation.rb

@@ -5,16 +5,19 @@ class Thor
     #
     def initialize(args=[], options={}, config={}, &block) #:nodoc:
       @_invocations = config[:invocations] || Hash.new { |h,k| h[k] = [] }
-      @_initializer = block || lambda do |klass, invoke, overrides|
-        klass.new(args, options, config.merge(overrides))
-      end
+      config[:invocations] = @_invocations # Cache in the config hash to be shared
+
+      @_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 name, it can also be supplied as second argument. The
-    # arguments used to invoke the task are always supplied as the last argument.
+    # 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.
     #
     # ==== Examples
     #
@@ -54,7 +57,7 @@ class Thor
     #     end
     #   end
     #
-    # As you notice, it invokes the given mock framework, which might have its
+    # As you noticed, it invokes the given mock framework, which might have its
     # own options:
     #
     #   class Rspec::RR < Thor::Group
@@ -68,29 +71,30 @@ class Thor
     # If you want Rspec::RR to be initialized with its own set of options, you
     # have to do that explicitely:
     #
-    #   invoke Rspec::RR.new([], :style => :foo)
+    #   invoke "rspec:rr", [], :style => :foo
     #
     # Besides giving an instance, you can also give a class to invoke:
     #
-    #   invoke Rspec::RR
-    #
-    # Or even a class, the task to invoke from it and its arguments:
-    #
-    #   invoke Rspec::RR, :foo, [ args ]
+    #   invoke Rspec::RR, [], :style => :foo
     #
-    def invoke(name, task=nil, method_args=nil)
-      task, method_args = nil, task if task.is_a?(Array)
+    def invoke(name=nil, task=nil, args=nil, opts=nil, config={})
+      task, args, opts, config = nil, task, args, opts if task.is_a?(Array)
       object, task = _setup_for_invoke(name, task)
 
       if object.is_a?(Class)
         klass = object
-        instance, trailing = @_initializer.call(klass, task, _overrides_config)
-        method_args ||= trailing
+
+        stored_args, stored_opts, stored_config = @_initializer
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
+        config = stored_config.merge(config)
+
+        instance = klass.new(args, opts, config)
       else
         klass, instance = object.class, object
       end
 
-      method_args ||= []
+      method_args = []
       current = @_invocations[klass]
 
       iterator = lambda do |_, task|
@@ -101,21 +105,16 @@ class Thor
       end
 
       if task
+        args ||= []
+        method_args = args[Range.new(klass.arguments.size, -1)] || []
         iterator.call(nil, task)
       else
-        method_args = []
         klass.all_tasks.map(&iterator)
       end
     end
 
     protected
 
-      # Values that are sent to overwrite defined configuration values.
-      #
-      def _overrides_config #:nodoc:
-        { :invocations => @_invocations }
-      end
-
       # This is the method responsable for retrieving and setting up an
       # instance to be used in invoke.
       #

data/lib/thor/parser/argument.rb

@@ -0,0 +1,66 @@
+class Thor
+  class Argument
+    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, "#{class_name} cannot be required and have default value." if required && !default.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 || :default).to_sym
+      @default     = default
+      @banner      = banner || default_banner
+    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
+
+    def input_required?
+      [ :numeric, :hash, :array, :string ].include?(type)
+    end
+
+    protected
+
+      def valid_type?(type)
+        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/thor/parser/arguments.rb

@@ -0,0 +1,140 @@
+class Thor
+  class Arguments
+    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(base, args)
+      new(base).parse(args)
+    end
+
+    # Takes an array of Thor::Argument objects.
+    #
+    def initialize(arguments=[])
+      @arguments = arguments
+      @non_assigned_required = @arguments.select { |a| a.required? }
+    end
+
+    def parse(args)
+      @pile, assigns = args.dup, {}
+
+      @arguments.each do |argument|
+        assigns[argument.human_name] = if peek
+          @non_assigned_required.delete(argument)
+          send(:"parse_#{argument.type}", argument.human_name)
+        else
+          argument.default
+        end
+      end
+
+      check_requirement!
+      assigns
+    end
+
+    private
+
+      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(':')
+          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 peel is numeric ofrmat 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, i.e., just return the current value in the pile.
+      #
+      def parse_string(name)
+        shift
+      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