josevalim-thor 0.10.10 → 0.10.11

data/lib/thor/actions.rb

@@ -306,10 +306,10 @@ class Thor
 
     protected
 
-      # Update dump_config to dump also behavior and root.
+      # Allow current root to be sent as configuration value to the invoked class.
       #
-      def _dump_config #:nodoc:
-        super.merge!(:behavior => self.behavior, :root => @root_stack[0])
+      def _overrides_config #:nodoc:
+        super.merge!(:root => self.root)
       end
 
   end

data/lib/thor/base.rb

@@ -1,64 +1,81 @@
 require 'thor/core_ext/hash_with_indifferent_access'
 require 'thor/core_ext/ordered_hash'
-require 'thor/shell/basic'
 require 'thor/error'
+require 'thor/shell'
+require 'thor/invocation'
 require 'thor/options'
 require 'thor/task'
 require 'thor/util'
 
 class Thor
   HELP_MAPPINGS       = %w(-h -? --help -D)
-  RESERVED_TASK_NAMES = %w(all invoke shell options behavior root destination_root relative_root source_root)
+  THOR_RESERVED_WORDS = %w(all invoke shell options behavior root destination_root relative_root source_root)
 
   class Maxima < Struct.new(:usage, :options, :class_options)
   end
 
   module Base
+    attr_accessor :options
 
-    def self.included(base) #:nodoc:
-      base.send :extend,  ClassMethods
-      base.send :include, SingletonMethods
-    end
-
-    # Returns the classes that inherits from Thor or Thor::Group.
+    # It receives arguments in an Array and two hashes, one for options and
+    # other for configuration.
     #
-    # ==== Returns
-    # Array[Class]
+    # Notice that it does not check arguments type neither if all required
+    # arguments were supplied. It should be done by the parser.
     #
-    def self.subclasses
-      @subclasses ||= []
-    end
-
-    # Returns the files where the subclasses are kept.
+    # ==== Parameters
+    # args<Array[Object]>:: An array of objects. The objects are applied to their
+    #                       respective accessors declared with <tt>argument</tt>.
     #
-    # ==== Returns
-    # Hash[path<String> => Class]
+    # options<Hash>:: An options hash that will be available as self.options.
+    #                 The hash given is converted to a hash with indifferent
+    #                 access, magic predicates (options.skip?) and then frozen.
     #
-    def self.subclass_files
-      @subclass_files ||= Hash.new{ |h,k| h[k] = [] }
-    end
-
-    # Returns the shell used in all Thor classes.
+    # config<Hash>:: Configuration for this Thor class.
     #
-    def self.shell
-      @shell || Thor::Shell::Basic
-    end
+    def initialize(args=[], options={}, config={})
+      self.class.arguments.zip(args).each do |argument, value|
+        send("#{argument.human_name}=", value)
+      end
 
-    # Sets the shell used in all Thor classes.
-    #
-    def self.shell=(klass)
-      @shell = klass
+      self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).freeze
     end
 
-    # Whenever a class inherits from Thor or Thor::Group, we should track the
-    # class and the file on Thor::Base. This is the method responsable for it.
-    #
-    def self.register_klass_file(klass) #:nodoc:
-      file = caller[1].match(/(.*):\d+/)[1]
-      Thor::Base.subclasses << klass unless Thor::Base.subclasses.include?(klass)
+    class << self
+      def included(base) #:nodoc:
+        base.send :extend,  ClassMethods
+        base.send :include, Invocation
+        base.send :include, Shell
+      end
+
+      # Returns the classes that inherits from Thor or Thor::Group.
+      #
+      # ==== Returns
+      # Array[Class]
+      #
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # Returns the files where the subclasses are kept.
+      #
+      # ==== Returns
+      # Hash[path<String> => Class]
+      #
+      def subclass_files
+        @subclass_files ||= Hash.new{ |h,k| h[k] = [] }
+      end
 
-      file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
-      file_subclasses << klass unless file_subclasses.include?(klass)
+      # Whenever a class inherits from Thor or Thor::Group, we should track the
+      # class and the file on Thor::Base. This is the method responsable for it.
+      #
+      def register_klass_file(klass) #:nodoc:
+        file = caller[1].match(/(.*):\d+/)[1]
+        Thor::Base.subclasses << klass unless Thor::Base.subclasses.include?(klass)
+
+        file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
+        file_subclasses << klass unless file_subclasses.include?(klass)
+      end
     end
 
     module ClassMethods
@@ -97,6 +114,7 @@ class Thor
       # ArgumentError:: Raised if you supply a required argument after a non required one.
       #
       def argument(name, options={})
+        is_thor_reserved_word?(name, :argument)
         no_tasks { attr_accessor name }
 
         required = if options.key?(:optional)
@@ -308,6 +326,26 @@ 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
+
       protected
 
         # Prints the class optins per group. If a class options does not belong
@@ -350,6 +388,13 @@ class Thor
           end
         end
 
+        # Raises an error if the word given is a Thor reserved word.
+        #
+        def is_thor_reserved_word?(word, type)
+          return false unless THOR_RESERVED_WORDS.include?(word.to_s)
+          raise ScriptError, "'#{word}' is a Thor reserved word and cannot be defined as #{type}"
+        end
+
         # Build an option and adds it to the given scope.
         #
         # ==== Parameters
@@ -408,11 +453,7 @@ class Thor
           end
 
           return if @no_tasks || !valid_task?(meth)
-
-          if RESERVED_TASK_NAMES.include?(meth)
-            raise ScriptError, "'#{meth}' is a Thor reserved word and cannot be defined as task"
-          end
-
+          is_thor_reserved_word?(meth, :task)
           Thor::Base.register_klass_file(self)
           create_task(meth)
         end
@@ -445,192 +486,18 @@ class Thor
         # class.
         def initialize_added #:nodoc:
         end
-    end
-
-    module SingletonMethods
-      attr_accessor :options
-
-      SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
 
-      # It receives arguments in an Array and two hashes, one for options and
-      # other for configuration.
-      #
-      # Notice that it does not check arguments type neither if all required
-      # arguments were supplied. It should be done by the parser.
-      #
-      # ==== Parameters
-      # args<Array[Object]>:: An array of objects. The objects are applied to their
-      #                       respective accessors declared with <tt>argument</tt>.
-      #
-      # options<Hash>:: An options hash that will be available as self.options.
-      #                 The hash given is converted to a hash with indifferent
-      #                 access, magic predicates (options.skip?) and then frozen.
-      #
-      # config<Hash>:: Configuration for this Thor class.
-      #
-      # ==== Configuration
-      # shell<Object>:: An instance of the shell to be used.
-      #
-      # ==== Examples
-      #
-      #   class MyScript < Thor
-      #     argument :first, :type => :numeric
-      #   end
-      #
-      #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
-      #
-      def initialize(args=[], options={}, config={})
-        self.class.arguments.zip(args).each do |argument, value|
-          send("#{argument.human_name}=", value)
+        # 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
 
-        self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).freeze
-
-        # Configure shell and set base if not already
-        self.shell = config[:shell]
-        self.shell.base ||= self if self.shell.respond_to?(:base)
-      end
-
-      # Holds the shell for the given Thor instance. If no shell is given,
-      # it gets a default shell from Thor::Base.shell.
-      #
-      def shell
-        @shell ||= Thor::Base.shell.new
-      end
-
-      # Sets the shell for this thor class.
-      #
-      def shell=(shell)
-        @shell = shell
-      end
-
-      # Common methods that are delegated to the shell.
-      #
-      SHELL_DELEGATED_METHODS.each do |method|
-        module_eval <<-METHOD, __FILE__, __LINE__
-          def #{method}(*args)
-            shell.#{method}(*args)
-          end
-        METHOD
-      end
-
-      # Receives a name and invokes it. The name can be either a namespaced name,
-      # a current class task or even a class. Arguments are given in an array and
-      # options given are merged with the invoker options.
-      #
-      # ==== Examples
-      #
-      #   class A < Thor
-      #     def foo
-      #       invoke :bar
-      #       invoke "b:lib", ["merb", "rails"]
-      #     end
-      #
-      #     def bar
-      #       invoke "b:lib", ["merb", "rails"]
-      #       # magic
-      #     end
-      #   end
-      #
-      #   class B < Thor
-      #     argument :preferred_framework, :type => :string
-      #
-      #     def lib(second_framework)
-      #       # magic
-      #     end
-      #   end
-      #
-      # You can notice that the method "foo" above invokes two tasks: "bar",
-      # which belongs to the same class and "lib" that 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:lib" just once, even if
-      # it's invoked later by "bar" method.
-      #
-      # When invoking another class, there are a few things to keep in mind:
-      #
-      #   1) Class arguments are parsed first. In the example above, preferred
-      #      framework is going to consume "merb" and second framework is going
-      #      to be set to "rails".
-      #
-      #   2) All options and configurations are sent to the invoked class.
-      #      So the invoked class is going to use the same shell instance, will
-      #      have the same behavior (:invoke or :revoke) and so on.
-      #
-      # Invoking a Thor::Group happens in the same away as above:
-      #
-      #   class C < Thor::Group
-      #     def one
-      #     end
-      #   end
-      #
-      # Is invoked as:
-      #
-      #   invoke "c"
-      #
-      # Or even as:
-      #
-      #   invoke C
-      #
-      def invoke(name, method_args=[], options={})
-        @_invocations ||= Hash.new { |h,k| h[k] = [] }
-        instance, task = _setup_for_invoke(name, method_args, options)
-
-        current = @_invocations[instance.class]
-        return if current.include?("all")
-
-        if task
-          task = self.class.all_tasks[task.to_s] || Task.dynamic(task) unless task.is_a?(Thor::Task)
-          return if current.include?(task.name)
-
-          current << task.name
-          task.run(instance, method_args)
-        else
-          current << "all"
-          instance.class.all_tasks.collect { |_, task| task.run(instance) }
+        # 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
-
-      protected
-
-        # This is the method responsable for retrieving and setting up an
-        # instance to be used in invoke.
-        #
-        def _setup_for_invoke(name, method_args, options) #:nodoc:
-          case name
-            when NilClass, Thor::Task
-              # Do nothing, we already have what we want
-            when Class
-              klass = name
-            else
-              name = name.to_s
-              unless self.class.all_tasks[name]
-                klass, task = Thor::Util.namespace_to_thor_class(name) rescue Thor::Error
-              end
-          end
-
-          if klass.nil?
-            return self, name
-          elsif klass <= Thor::Base
-            size       = klass.arguments.size
-            class_args = method_args.slice!(0, size)
-            instance   = klass.new(class_args, self.options.merge(options), _dump_config)
-
-            task ||= klass.default_task if klass <= Thor
-            instance.instance_variable_set("@_invocations", @_invocations)
-
-            return instance, task
-          else
-            raise ScriptError, "Expected Thor class, got #{klass}"
-          end
-        end
-
-        # Dump the configuration values for this current class.
-        #
-        def _dump_config #:nodoc:
-          { :shell => self.shell }
-        end
-
     end
   end
 end

data/lib/thor/group.rb

@@ -3,8 +3,8 @@ class Thor::Group
   class << self
 
     # The descrition for this Thor::Group. If none is provided, but a source root
-    # exists and we have an USAGE inside, this file is used as description. This
-    # is good because we will load such files only when we need it.
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
     #
     # ==== Parameters
     # description<String>:: The description for this Thor::Group.
@@ -12,8 +12,9 @@ class Thor::Group
     def desc(description=nil)
       case description
         when nil
-          @desc ||= if respond_to?(:source_root) && File.exist?(File.join(source_root, "USAGE"))
-            File.read(File.join(source_root, "USAGE"))
+          usage = File.join(source_root, "..", "USAGE") if respond_to?(:source_root)
+          @desc ||= if usage && File.exist?(usage)
+            File.read(usage)
           else
             from_superclass(:desc, nil)
           end
@@ -22,22 +23,17 @@ class Thor::Group
       end
     end
 
-    # Start in Thor::Group works differently. It invokes all tasks inside the
-    # class and does not have to parse task options.
+    # Implements the prepare interface being used by start.
     #
-    def start(args=ARGV, config={})
-      config[:shell] ||= Thor::Base.shell.new
+    def prepare(task, args, config) #:nodoc:
+      opts = Thor::Options.new(class_options)
+      opts.parse(args)
 
-      if Thor::HELP_MAPPINGS.include?(args.first)
-        help(config[:shell])
-      else
-        opts = Thor::Options.new(class_options)
-        opts.parse(args)
-
-        new(opts.arguments, opts.options, config).invoke(:all)
+      instance = new(opts.arguments, opts.options, config) do |klass, invoke|
+        klass.prepare(invoke, args, config)
       end
-    rescue Thor::Error => e
-      config[:shell].error e.message
+
+      return instance, nil
     end
 
     # Prints help information.
@@ -77,6 +73,15 @@ 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
@@ -86,9 +91,8 @@ class Thor::Group
     # Overwrite _setup_for_invoke to force invocation of all tasks when :all is
     # supplied.
     #
-    def _setup_for_invoke(name, method_args, options)
-      name = nil if name.to_s == "all"
-      super(name, method_args, options)
+    def _setup_for_invoke(object, task=nil)
+      super(object.to_s == "all" ? nil : object)
     end
 
 end

data/lib/thor/invocation.rb

@@ -0,0 +1,148 @@
+class Thor
+  module Invocation
+
+    # Make initializer aware of invocations and the initializer proc.
+    #
+    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
+      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.
+    #
+    # ==== 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 notice, 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 explicitely:
+    #
+    #   invoke Rspec::RR.new([], :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 ]
+    #
+    def invoke(name, task=nil, method_args=nil)
+      task, method_args = nil, task if task.is_a?(Array)
+
+      object, task = _setup_for_invoke(name, task)
+      klass = object.is_a?(Class) ? object : object.class
+
+      current = @_invocations[klass]
+      return if current.include?("all")
+
+      if object.is_a?(Class)
+        instance, trailing = @_initializer.call(klass, task, _overrides_config)
+        method_args ||= trailing
+      else
+        instance = object
+      end
+
+      method_args ||= []
+
+      if task
+        return if current.include?(task.name)
+        current << task.name
+        task.run(instance, method_args)
+      else
+        current << "all"
+        klass.all_tasks.collect { |_, task| task.run(instance) }
+      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.
+      #
+      def _setup_for_invoke(name, sent_task=nil) #:nodoc:
+        case name
+          when Thor::Task
+            task = name
+          when Symbol, String
+            name = name.to_s
+
+            begin
+              task = self.class.all_tasks[name]
+              object, task = Thor::Util.namespace_to_thor_class(name) unless task
+              task = task || sent_task
+            rescue Thor::Error
+              task = name
+            end
+          else
+            object, task = name, sent_task
+        end
+
+        object ||= self
+        klass = object.is_a?(Class) ? object : object.class
+        raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
+
+        task ||= klass.default_task if klass <= Thor
+        task = klass.all_tasks[task.to_s] || Task.dynamic(task) if task && !task.is_a?(Thor::Task)
+        return object, task
+      end
+
+  end
+end

data/lib/thor/options.rb

@@ -77,7 +77,7 @@ class Thor
     end
 
     def parse(args)
-      @pile, @trailing = args, []
+      @pile, @trailing = args.dup, []
 
       while peek
         if current_is_switch?

data/lib/thor/shell/basic.rb

@@ -125,30 +125,28 @@ class Thor
       #
       def file_collision(destination)
         return true if @always_force
-
         options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
-        answer  = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
-
-        case answer
-          when is?(:yes), is?(:force)
-            true
-          when is?(:no), is?(:skip)
-            false
-          when is?(:always)
-            @always_force = true
-          when is?(:quit)
-            say 'Aborting...'
-            raise SystemExit
-          when is?(:diff)
-            show_diff(destination, yield) if block_given?
-            say 'Retrying...'
-            raise ScriptError
-          else
-            say file_collision_help
-            raise ScriptError
+
+        while true
+          answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
+
+          case answer
+            when is?(:yes), is?(:force)
+              return true
+            when is?(:no), is?(:skip)
+              return false
+            when is?(:always)
+              return @always_force = true
+            when is?(:quit)
+              say 'Aborting...'
+              raise SystemExit
+            when is?(:diff)
+              show_diff(destination, yield) if block_given?
+              say 'Retrying...'
+            else
+              say file_collision_help
+          end
         end
-      rescue ScriptError
-        retry
       end
 
       # Called if something goes wrong during the execution. This is used by Thor

data/lib/thor/shell.rb

@@ -0,0 +1,71 @@
+require 'thor/shell/basic'
+
+class Thor
+  module Base
+    # Returns the shell used in all Thor classes.
+    #
+    def self.shell
+      @shell || Thor::Shell::Basic
+    end
+
+    # Sets the shell used in all Thor classes.
+    #
+    def self.shell=(klass)
+      @shell = klass
+    end
+  end
+
+  module Shell
+    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
+
+    # Add shell to initialize config values.
+    #
+    # ==== Configuration
+    # shell<Object>:: An instance of the shell to be used.
+    #
+    # ==== Examples
+    #
+    #   class MyScript < Thor
+    #     argument :first, :type => :numeric
+    #   end
+    #
+    #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+    #
+    def initialize(args=[], options={}, config={})
+      super
+      self.shell = config[:shell]
+      self.shell.base ||= self if self.shell.respond_to?(:base)
+    end
+
+    # Holds the shell for the given Thor instance. If no shell is given,
+    # it gets a default shell from Thor::Base.shell.
+    #
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    # Sets the shell for this thor class.
+    #
+    def shell=(shell)
+      @shell = shell
+    end
+
+    # Common methods that are delegated to the shell.
+    #
+    SHELL_DELEGATED_METHODS.each do |method|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{method}(*args)
+          shell.#{method}(*args)
+        end
+      METHOD
+    end
+
+    protected
+
+      # Send the current shell to be used by the invoked class.
+      #
+      def _overrides_config #:nodoc:
+        super.merge!(:shell => self.shell)
+      end
+  end
+end

data/lib/thor.rb

@@ -115,28 +115,18 @@ class Thor
       build_option(name, options, scope)
     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:
+    # Implements the prepare interface being used by start.
     #
-    #   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
-
-      meth = normalize_task_name(args.shift)
-      task = all_tasks[meth] || Task.dynamic(meth)
-
+    def prepare(task, args, config) #:nodoc:
       options = class_options.merge(task.options)
       opts = Thor::Options.new(options)
       opts.parse(args)
 
-      instance = new(opts.arguments, opts.options, config)
-      instance.invoke(task, opts.trailing)
-    rescue Thor::Error => e
-      config[:shell].error e.message
+      instance = new(opts.arguments, opts.options, config) do |klass, invoke, overrides|
+        klass.prepare(invoke, args, config.merge(overrides))
+      end
+
+      return instance, opts.trailing
     end
 
     # Prints help information. If a task name is given, it shows information
@@ -207,6 +197,11 @@ class Thor
         @method_options = nil
       end
 
+      def normalize_arguments(args, config) #:nodoc:
+        meth = normalize_task_name(args.shift)
+        all_tasks[meth] || Task.dynamic(meth)
+      end
+
       # Receives a task name (can be nil), and try to get a map from it.
       # If a map can't be found use the sent name or the default task.
       #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: josevalim-thor
 version: !ruby/object:Gem::Version 
-  version: 0.10.10
+  version: 0.10.11
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-20 00:00:00 -07:00
+date: 2009-06-23 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -52,6 +52,7 @@ files:
 - lib/thor/options.rb
 - lib/thor/shell
 - lib/thor/shell/basic.rb
+- lib/thor/invocation.rb
 - lib/thor/tasks.rb
 - lib/thor/core_ext
 - lib/thor/core_ext/hash_with_indifferent_access.rb
@@ -60,6 +61,7 @@ files:
 - lib/thor/tasks/install.rb
 - lib/thor/tasks/spec.rb
 - lib/thor/tasks/package.rb
+- lib/thor/shell.rb
 - lib/thor/task.rb
 has_rdoc: true
 homepage: http://yehudakatz.com