thor 0.13.8 → 0.14.0

data/CHANGELOG.rdoc

@@ -2,6 +2,7 @@
 
 * Added :lazy_default which is only triggered if a switch is given
 * Added Thor::Shell::HTML
+* Added subcommands
 * Decoupled Thor::Group and Thor, so it's easier to vendor
 * Added check_unknown_options! in case you want error messages to be raised in valid switches
 * run(command) should return the results of command
@@ -21,7 +22,7 @@
   Thor classes.
 
 * BACKWARDS INCOMPATIBLE: aliases are not generated automatically anymore
-  since it wrong behavior to the invocation system.
+  since it may cause wrong behavior in the invocation system.
 
 * thor help now show information about any class/task. All those calls are
   possible:

data/{README.rdoc → README.md}

@@ -1,7 +1,21 @@
-= thor
+# Thor 
 
-Map options to a class. Simply create a class with the appropriate annotations
-and have options automatically map to functions and parameters.
+## Description
+
+Thor is a simple and efficient tool for building self-documenting command line utilities.  It removes the pain of parsing command line options, writing "USAGE:" banners, and can also be used as an alternative to the [Rake](http://github.com/jimweirich/rake) build tool.  The syntax is Rake-like, so it should be familiar to most Rake users. 
+
+## Installation
+
+$ gem install thor
+
+or
+
+$ gem install wycats-thor -s http://gems.github.com
+
+## Usage
+
+Map options to a class.  Simply create a class with the appropriate annotations
+and have options automatically map to functions and parameters.  
 
 Example:
 
@@ -24,7 +38,7 @@ Example:
       end
     end
 
-Thor automatically maps commands as such:
+Thor automatically maps commands as such: 
 
     thor app:install myname --force
 
@@ -33,12 +47,12 @@ That gets converted to:
     App.new.install("myname")
     # with {'force' => true} as options hash
 
-1. Inherit from Thor to turn a class into an option mapper
-2. Map additional non-valid identifiers to specific methods. In this case, convert -L to :list
-3. Describe the method immediately below. The first parameter is the usage information, and the second parameter is the description
-4. Provide any additional options that will be available the instance method options.
+1. Inherit from Thor to turn a class into an option mapper.  
+2. Map additional non-valid identifiers to specific methods.  In this case, convert -L to :list
+3. Describe the method immediately below.  The first parameter is the usage information, and the second parameter is the description.  
+4. Provide any additional options that will be available the instance method options.  
 
-== Types for <tt>method_options</tt>
+## Types for <tt>method_options</tt>
 
 * :boolean - is parsed as <tt>--option</tt> or <tt>--option=true</tt>
 * :string  - is parsed as <tt>--option=VALUE</tt>
@@ -46,7 +60,7 @@ That gets converted to:
 * :array   - is parsed as <tt>--option=one two three</tt>
 * :hash    - is parsed as <tt>--option=name:string age:integer</tt>
 
-Besides, method_option allows a default value to be given, examples:
+Besides, method_option allows a default value to be given.  Examples:
 
     method_options :force => false
     #=> Creates a boolean option with default value false
@@ -57,19 +71,19 @@ Besides, method_option allows a default value to be given, examples:
     method_options :threshold => 3.0
     #=> Creates a numeric option with default value 3.0
 
-You can also supply <tt>:option => :required</tt> to mark an option as required. The
-type is assumed to be string. If you want a required hash with default values
+You can also supply <tt>:option => :required</tt> to mark an option as required.  The
+type is assumed to be string.  If you want a required hash with default values
 as option, you can use <tt>method_option</tt> which uses a more declarative style:
 
     method_option :attributes, :type => :hash, :default => {}, :required => true
 
 All arguments can be set to nil (except required arguments), by suppling a no or
-skip variant. For example:
+skip variant.  For example: 
 
     thor app name --no-attributes
 
 In previous versions, aliases for options were created automatically, but now
-they should be explicit. You can supply aliases in both short and declarative
+they should be explicit.  You can supply aliases in both short and declarative
 styles:
 
     method_options %w( force -f ) => :boolean
@@ -82,9 +96,9 @@ You can supply as many aliases as you want.
 
 NOTE: Type :optional available in Thor 0.9.0 was deprecated. Use :string or :boolean instead.
 
-== Namespaces
+## Namespaces
 
-By default, your Thor tasks are invoked using Ruby namespace. In the example
+By default, your Thor tasks are invoked using Ruby namespace.  In the example
 above, tasks are invoked as:
 
     thor app:install name --force
@@ -110,14 +124,13 @@ If desired, you can change the namespace:
       end
     end
 
-And then your tasks hould be invoked as:
+And then your tasks should be invoked as:
 
     thor myapp:install name --force
 
-== Invocations
+## Invocations
 
-Thor comes with a invocation-dependency system as well which allows a task to be
-invoked only once. For example:
+Thor comes with a invocation-dependency system as well, which allows a task to be invoked only once.  For example:
 
     class Counter < Thor
       desc "one", "Prints 1, 2, 3"
@@ -143,14 +156,14 @@ When invoking the task one:
 
     thor counter:one
 
-The output is "1 2 3", which means that the three task was invoked only once.
+The output is "1 2 3", which means that the three task was invoked only once.  
 You can even invoke tasks from another class, so be sure to check the
-documentation[http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html].
+[documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html).
 
-== Thor::Group
+## Thor::Group
 
-Thor has a special class called Thor::Group. The main difference to Thor class
-is that it invokes all tasks at once. The example above could be rewritten in
+Thor has a special class called Thor::Group.  The main difference to Thor class
+is that it invokes all tasks at once.  The example above could be rewritten in
 Thor::Group as this:
 
     class Counter < Thor::Group
@@ -173,12 +186,12 @@ When invoked:
 
     thor counter
 
-It prints "1 2 3" as well. Notice you should describe (using the method <tt>desc</tt>)
-only the class and not each task anymore. Thor::Group is a great tool to create
+It prints "1 2 3" as well.  Notice you should describe (using the method <tt>desc</tt>)
+only the class and not each task anymore.  Thor::Group is a great tool to create
 generators, since you can define several steps which are invoked in the order they
-are defined (Thor::Group is the tool use in generators in Rails 3.0).
+are defined (Thor::Group is the tool use in generators in Rails 3.0). 
 
-Besides, Thor::Group can parse arguments and options as Thor tasks:
+Besides, Thor::Group can parse arguments and options as Thor tasks: 
 
     class Counter < Thor::Group
       # number will be available as attr_accessor
@@ -210,13 +223,13 @@ You can also give options to Thor::Group, but instead of using <tt>method_option
 and <tt>method_options</tt>, you should use <tt>class_option</tt> and <tt>class_options</tt>.
 Both argument and class_options methods are available to Thor class as well.
 
-== Actions
+## Actions
 
-Thor comes with several actions which helps with script and generator tasks. You
-might be familiar with them since some came from Rails Templates. They are:
+Thor comes with several actions which helps with script and generator tasks.  You
+might be familiar with them since some came from Rails Templates.  They are:
 <tt>say</tt>, <tt>ask</tt>, <tt>yes?</tt>, <tt>no?</tt>, <tt>add_file</tt>,
 <tt>remove_file</tt>, <tt>copy_file</tt>, <tt>template</tt>, <tt>directory</tt>,
-<tt>inside</tt>, <tt>run</tt>, <tt>inject_into_file</tt> and a couple more.
+<tt>inside</tt>, <tt>run</tt>, <tt>inject_into_file</tt> and a couple more. 
 
 To use them, you just need to include Thor::Actions in your Thor classes:
 
@@ -226,13 +239,13 @@ To use them, you just need to include Thor::Actions in your Thor classes:
     end
 
 Some actions like copy file requires that a class method called source_root is
-defined in your class. This is the directory where your templates should be
-placed. Be sure to check the documentation on actions[http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html].
+defined in your class.  This is the directory where your templates should be
+placed.  Be sure to check the documentation on [actions](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html).
 
-== Generators
+## Generators
 
-A great use for Thor is creating custom generators. Combining Thor::Group,
-Thor::Actions and ERB templates makes this very easy. Here is an example:
+A great use for Thor is creating custom generators.  Combining Thor::Group,
+Thor::Actions and ERB templates makes this very easy.  Here is an example:
 
     class Newgem < Thor::Group
       include Thor::Actions
@@ -264,8 +277,8 @@ Thor::Actions and ERB templates makes this very easy. Here is an example:
       end
     end
 
-Doing a <tt>thor -T</tt> will show how to run our generator. It should read:
-<tt>thor newgem NAME</tt>. This shows that we have to supply a NAME
+Doing a <tt>thor -T</tt> will show how to run our generator.  It should read:
+<tt>thor newgem NAME</tt>.  This shows that we have to supply a NAME
 argument for our generator to run.
 
 The <tt>create_lib_file</tt> uses an ERB template. This is what it looks like:
@@ -274,24 +287,19 @@ The <tt>create_lib_file</tt> uses an ERB template. This is what it looks like:
     end
 
 The arguments that you set in your generator will automatically be passed in
-when <tt>template</tt> gets called. Be sure to read the documentation[http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html] for
+when <tt>template</tt> gets called.  Be sure to read the [documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html) for
 more options.
 
 Running the generator with <tt>thor newgem devise</tt> will
-create two files: "devise/lib/devise.rb",
-"devise/test/devise_test.rb". The user will then be prompt (with the
-use of the method <tt>yes?</tt>) if he wants to copy the MITLICENSE. If you
-want to change the test framework, you can add the option:
-<tt>thor newgem devise --test-framework=rspec</tt>
-This will generate: "devise/lib/devise.rb" and
-"devise/spec/devise_spec.rb".
+create two files: "devise/lib/devise.rb", and "devise/test/devise_test.rb".  The user will then be asked (via a prompt by the <tt>yes?</tt> method) whether or not they would like to copy the MIT License.  If you want to change the test framework, you can add the option: <tt>thor newgem devise --test-framework=rspec</tt> 
+
+This will generate two files - "devise/lib/devise.rb" and "devise/spec/devise_spec.rb".
 
-== Further Reading
+## Further Reading
 
-Thor has many scripting possibilities beyond these examples. Be sure to read
-through the documentation[http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html] and specs[http://github.com/wycats/thor/tree/master/spec/] to get a better understanding of all the
-options Thor offers.
+Thor offers many scripting possibilities beyond these examples.  Be sure to read
+through the [documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html) and [specs](http://github.com/wycats/thor/tree/master/spec/) to get a better understanding of the options available. 
 
-== License
+## License
 
-See MIT LICENSE.
+Released under the MIT License.  See the LICENSE file for further details. 

data/Thorfile

@@ -10,7 +10,7 @@ rescue LoadError
 end
 
 GEM_NAME = 'thor'
-EXTRA_RDOC_FILES = ["README.rdoc", "LICENSE", "CHANGELOG.rdoc", "VERSION", "Thorfile"]
+EXTRA_RDOC_FILES = ["README.md", "LICENSE", "CHANGELOG.rdoc", "VERSION", "Thorfile"]
 
 class Default < Thor
   include Thor::RakeCompat
@@ -44,7 +44,7 @@ class Default < Thor
     require 'jeweler'
     Jeweler::Tasks.new do |s|
       s.name = GEM_NAME
-      s.version = Thor::VERSION
+      s.version = Thor::VERSION.dup
       s.rubyforge_project = "textmate"
       s.platform = Gem::Platform::RUBY
       s.summary = "A scripting framework that replaces rake, sake and rubigen"

data/lib/thor.rb

@@ -126,42 +126,6 @@ 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:
-    #
-    #   script = MyScript.new(args, options, config)
-    #   script.invoke(:task, first_arg, second_arg, third_arg)
-    #
-    def start(original_args=ARGV, config={})
-      @@original_args = original_args
-
-      super do |given_args|
-        meth = given_args.first.to_s
-
-        if !meth.empty? && (map[meth] || meth !~ /^\-/)
-          given_args.shift
-        else
-          meth = nil
-        end
-
-        meth = normalize_task_name(meth)
-        task = all_tasks[meth]
-
-        if task
-          args, opts = Thor::Options.split(given_args)
-          config.merge!(:task_options => task.options)
-        else
-          args, opts = given_args, {}
-        end
-
-        task ||= Thor::DynamicTask.new(meth)
-        trailing = args[Range.new(arguments.size, -1)]
-        new(args, opts, config).invoke(task, trailing || [])
-      end
-    end
-
     # Prints help information for the given task.
     #
     # ==== Parameters
@@ -215,18 +179,73 @@ class Thor
     end
 
     def subcommands
-      @@subcommands ||= {}
+      @subcommands ||= from_superclass(:subcommands, [])
     end
 
     def subcommand(subcommand, subcommand_class)
-      subcommand = subcommand.to_s
-      subcommands[subcommand] = subcommand_class
+      self.subcommands << subcommand.to_s
       subcommand_class.subcommand_help subcommand
-      define_method(subcommand) { |*_| subcommand_class.start(subcommand_args) }
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end 
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
     end
 
     protected
 
+      # The method responsible for dispatching given the args.
+      def dispatch(meth, given_args, given_opts, config) #:nodoc:
+        meth ||= retrieve_task_name(given_args)
+        task = all_tasks[normalize_task_name(meth)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke_task(task, trailing || [])
+      end
+
       # The banner for this class. You can customize it if you are invoking the
       # thor class by another ways which is not the Thor::Runner. It receives
       # the task that is going to be invoked and a boolean which indicates if
@@ -243,10 +262,10 @@ class Thor
       def create_task(meth) #:nodoc:
         if @usage && @desc
           base_class = @hide ? Thor::HiddenTask : Thor::Task
-          tasks[meth.to_s] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
           @usage, @desc, @long_desc, @method_options, @hide = nil
           true
-        elsif self.all_tasks[meth.to_s] || meth.to_sym == :method_missing
+        elsif self.all_tasks[meth] || meth == "method_missing"
           true
         else
           puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
@@ -261,9 +280,19 @@ class Thor
         @method_options = nil
       end
 
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      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.
-      #
       def normalize_task_name(meth) #:nodoc:
         meth = map[meth.to_s] || meth || default_task
         meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
@@ -275,11 +304,6 @@ class Thor
           def help(task = nil, subcommand = true); super; end
         RUBY
       end
-
-  end
-
-  def subcommand_args
-    @@original_args[1..-1]
   end
 
   include Thor::Base

data/lib/thor/base.rb

@@ -53,7 +53,7 @@ class Thor
 
       opts = Thor::Options.new(parse_options, hash_options)
       self.options = opts.parse(array_options)
-      opts.check_unknown! if self.class.check_unknown_options?
+      opts.check_unknown! if self.class.check_unknown_options?(config)
     end
 
     class << self
@@ -114,8 +114,12 @@ class Thor
         @check_unknown_options = true
       end
 
-      def check_unknown_options? #:nodoc:
-        @check_unknown_options || false
+      def check_unknown_options #:nodoc:
+        @check_unknown_options ||= from_superclass(:check_unknown_options, false)
+      end
+
+      def check_unknown_options?(config) #:nodoc:
+        !!check_unknown_options
       end
 
       # Adds an argument to the class and creates an attr_accessor for it.
@@ -364,19 +368,25 @@ class Thor
       #
       def namespace(name=nil)
         case name
-          when nil
-            @namespace ||= Thor::Util.namespace_from_thor_class(self)
-          else
-            @namespace = name.to_s
+        when nil
+          @namespace ||= Thor::Util.namespace_from_thor_class(self)
+        else
+          @namespace = name.to_s
         end
       end
 
-      # Default way to start generators from the command line.
+      # 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(given_args=ARGV, config={})
-        self.debugging = given_args.include?("--debug")
+        self.debugging = given_args.delete("--debug")
         config[:shell] ||= Thor::Base.shell.new
-        yield(given_args.dup)
+        dispatch(nil, given_args.dup, nil, config)
       rescue Thor::Error => e
         debugging ? (raise e) : config[:shell].error(e.message)
         exit(1) if exit_on_failure?
@@ -535,6 +545,12 @@ class Thor
         # class.
         def initialize_added #:nodoc:
         end
+
+        # SIGNATURE: The hook invoked by start.
+        def dispatch(task, given_args, given_opts, config) #:nodoc:
+          raise NotImplementedError
+        end
+
     end
   end
 end

data/lib/thor/group.rb

@@ -22,21 +22,6 @@ class Thor::Group
       end
     end
 
-    # Start works differently in Thor::Group, it simply invokes all tasks
-    # inside the class.
-    #
-    def start(original_args=ARGV, config={})
-      super do |given_args|
-        if Thor::HELP_MAPPINGS.include?(given_args.first)
-          help(config[:shell])
-          return
-        end
-
-        args, opts = Thor::Options.split(given_args)
-        new(args, opts, config).invoke
-      end
-    end
-
     # Prints help information.
     #
     # ==== Options
@@ -225,6 +210,23 @@ class Thor::Group
 
     protected
 
+      # The method responsible for dispatching given the args.
+      def dispatch(task, given_args, given_opts, config) #:nodoc:
+        if Thor::HELP_MAPPINGS.include?(given_args.first)
+          help(config[:shell])
+          return
+        end
+
+        args, opts = Thor::Options.split(given_args)
+        opts = given_opts || opts
+
+        if task
+          new(args, opts, config).invoke_task(all_tasks[task])
+        else
+          new(args, opts, config).invoke_all
+        end
+      end
+
       # The banner for this class. You can customize it if you are invoking the
       # thor class by another ways which is not the Thor::Runner.
       def banner

data/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, !key)
-          else
-            name
+        when Symbol, String
+          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+        else
+          name
         end
       end
     end
@@ -94,29 +94,34 @@ 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)
+      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)
+    end
 
-      method_args = []
-      current = @_invocations[klass]
+    # Invoke the given task if the given args.
+    def invoke_task(task, *args) #:nodoc:
+      current = @_invocations[self.class]
 
-      iterator = proc do |_, task|
-        unless current.include?(task.name)
-          current << task.name
-          task.run(instance, method_args)
-        end
+      unless current.include?(task.name)
+        current << task.name
+        task.run(self, *args)
       end
+    end
 
-      if task
-        args ||= []
-        method_args = args[Range.new(klass.arguments.size, -1)] || []
-        iterator.call(nil, task)
-      else
-        klass.all_tasks.map(&iterator)
-      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.
@@ -131,50 +136,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::DynamicTask.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/thor/parser/options.rb

@@ -151,6 +151,8 @@ class Thor
           elsif option.string? && !option.required?
             # Return the default if there is one, else the 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

data/lib/thor/shell.rb

@@ -27,7 +27,7 @@ class Thor
 
     autoload :Basic, 'thor/shell/basic'
     autoload :Color, 'thor/shell/color'
-    autoload :HTML,  'thor/shell/HTML'
+    autoload :HTML,  'thor/shell/html'
 
     # Add shell to initialize config values.
     #

data/lib/thor/shell/basic.rb

@@ -35,13 +35,15 @@ class Thor
       # say("I know you knew that.")
       #
       def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
-        message  = message.to_s
-        message  = set_color(message, color) if color
+        message = message.to_s
+        message = set_color(message, color) if color
+
+        spaces = "  " * padding
 
         if force_new_line
-          $stdout.puts(message)
+          $stdout.puts(spaces + message)
         else
-          $stdout.print(message)
+          $stdout.print(spaces + message)
         end
         $stdout.flush
       end
@@ -58,7 +60,9 @@ class Thor
 
         status = status.to_s.rjust(12)
         status = set_color status, color, true if color
-        say "#{status}#{spaces}#{message}", nil, true
+
+        $stdout.puts "#{status}#{spaces}#{message}"
+        $stdout.flush
       end
 
       # Make a question the to user and returns true if the user replies "y" or

data/lib/thor/version.rb

@@ -1,3 +1,3 @@
 class Thor
-  VERSION = "0.13.8".freeze
+  VERSION = "0.14.0".freeze
 end

data/spec/base_spec.rb

@@ -244,6 +244,12 @@ describe Thor::Base do
         MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
       }.strip.must == "Unknown switches '--unknown'"
     end
+
+    it "checks unknown options except specified" do
+      capture(:stderr) {
+        MyScript.start(["with_optional", "NAME", "--omg", "--invalid"]).must == ["NAME", {}]
+      }.strip.must be_empty
+    end
   end
 
   describe "attr_*" do

data/spec/fixtures/script.thor

@@ -1,5 +1,5 @@
 class MyScript < Thor
-  check_unknown_options!
+  check_unknown_options! :except => :with_optional
 
   attr_accessor :some_attribute
   attr_writer :another_attribute
@@ -73,6 +73,9 @@ END
 
   method_options :all => :boolean
   method_option :lazy, :lazy_default => "yes"
+  method_option :lazy_numeric, :type => :numeric, :lazy_default => 42
+  method_option :lazy_array,   :type => :array,   :lazy_default => %w[eat at joes]
+  method_option :lazy_hash,    :type => :hash,    :lazy_default => {'swedish' => 'meatballs'}
   desc "with_optional NAME", "invoke with optional name"
   def with_optional(name=nil)
     [ name, options ]
@@ -136,6 +139,13 @@ class Barn < Thor
       puts "Open sesame!"
     end
   end
+
+  desc "paint [COLOR]", "paint the barn"
+  method_option :coats, :type => :numeric, :default => 2, :desc => 'how many coats of paint'
+  def paint(color='red')
+    puts "#{options[:coats]} coats of #{color} paint"
+  end
+
 end
 
 module Scripts
@@ -150,6 +160,8 @@ module Scripts
   end
 
   class MyDefaults < Thor
+    check_unknown_options!
+
     namespace :default
     desc "cow", "prints 'moo'"
     def cow

data/spec/invocation_spec.rb

@@ -37,13 +37,6 @@ describe Thor::Invocation do
       base.invoke(B, :one, ["Jose"]).must == "Valim, Jose"
     end
 
-    it "accepts a Thor instance as argument" do
-      invoked = B.new([], :last_name => "Valim")
-      base = A.new
-      base.invoke(invoked, :one, ["Jose"]).must == "Valim, Jose"
-      base.invoke(invoked, :one, ["Jose"]).must be_nil
-    end
-
     it "allows customized options to be given" do
       base = A.new([], :last_name => "Wrong")
       base.invoke(B, :one, ["Jose"], :last_name => "Valim").must == "Valim, Jose"
@@ -91,7 +84,7 @@ describe Thor::Invocation do
 
     it "raises Thor::UndefinedTaskError if the task can't be found even if all tasks where already executed" do
       base = C.new
-      silence(:stdout){ base.invoke }
+      silence(:stdout){ base.invoke_all }
 
       lambda do
         base.invoke("foo:bar")

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ require 'fakeweb'  # You need fakeweb installed to run specs (but not to run Tho
 # Set shell to basic
 $0 = "thor"
 $thor_runner = true
+ARGV.clear
 Thor::Base.shell = Thor::Shell::Basic
 
 # Load fixtures

data/spec/thor_spec.rb

@@ -8,15 +8,43 @@ describe Thor do
       options.must == { "force" => true }
     end
 
-    it "sets method_option with given parameters" do
-      arg, options = MyScript.start(["with_optional"])
-      options.must == {}
+    describe ":lazy_default" do
+      it "is absent when option is not specified" do
+        arg, options = MyScript.start(["with_optional"])
+        options.must == {}
+      end
+
+      it "sets a default that can be overridden for strings" do
+        arg, options = MyScript.start(["with_optional", "--lazy"])
+        options.must == { "lazy" => "yes" }
+
+        arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
+        options.must == { "lazy" => "yesyes!" }
+      end
+
+      it "sets a default that can be overridden for numerics" do
+        arg, options = MyScript.start(["with_optional", "--lazy-numeric"])
+        options.must == { "lazy_numeric" => 42 }
+
+        arg, options = MyScript.start(["with_optional", "--lazy-numeric", 20000])
+        options.must == { "lazy_numeric" => 20000 }
+      end
 
-      arg, options = MyScript.start(["with_optional", "--lazy"])
-      options.must == { "lazy" => "yes" }
+      it "sets a default that can be overridden for arrays" do
+        arg, options = MyScript.start(["with_optional", "--lazy-array"])
+        options.must == { "lazy_array" => %w[eat at joes] }
 
-      arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
-      options.must == { "lazy" => "yesyes!" }
+        arg, options = MyScript.start(["with_optional", "--lazy-array", "hello", "there"])
+        options.must == { "lazy_array" => %w[hello there] }
+      end
+
+      it "sets a default that can be overridden for hashes" do
+        arg, options = MyScript.start(["with_optional", "--lazy-hash"])
+        options.must == { "lazy_hash" => {'swedish' => 'meatballs'} }
+
+        arg, options = MyScript.start(["with_optional", "--lazy-hash", "polish:sausage"])
+        options.must == { "lazy_hash" => {'polish' => 'sausage'} }
+      end
     end
 
     describe "when :for is supplied" do
@@ -182,6 +210,10 @@ describe Thor do
     it "passes arguments to subcommand classes" do
       capture(:stdout){ Scripts::MyDefaults.start(["barn", "open", "shotgun"]) }.strip.must == "That's going to leave a mark."
     end
+
+    it "ignores unknown options (the subcommand class will handle them)" do
+      capture(:stdout){ Scripts::MyDefaults.start(["barn", "paint", "blue", "--coats", "4"])}.strip.must == "4 coats of blue paint"
+    end
   end
 
   describe "#help" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: thor
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 39
   prerelease: false
   segments: 
   - 0
-  - 13
-  - 8
-  version: 0.13.8
+  - 14
+  - 0
+  version: 0.14.0
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-16 00:00:00 +02:00
+date: 2010-07-26 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -30,12 +30,12 @@ extensions: []
 extra_rdoc_files: 
 - CHANGELOG.rdoc
 - LICENSE
-- README.rdoc
+- README.md
 - Thorfile
 files: 
 - CHANGELOG.rdoc
 - LICENSE
-- README.rdoc
+- README.md
 - Thorfile
 - bin/rake2thor
 - bin/thor