thor 0.13.7 → 0.13.8

data/CHANGELOG.rdoc

@@ -1,5 +1,6 @@
 == 0.13, released 2010-02-03
 
+* Added :lazy_default which is only triggered if a switch is given
 * Added Thor::Shell::HTML
 * 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

data/lib/thor.rb

@@ -23,6 +23,7 @@ class Thor
     # ==== Parameters
     # usage<String>
     # description<String>
+    # options<String>
     #
     def desc(usage, description, options={})
       if options[:for]
@@ -30,7 +31,7 @@ class Thor
         task.usage = usage             if usage
         task.description = description if description
       else
-        @usage, @desc = usage, description
+        @usage, @desc, @hide = usage, description, options[:hide] || false
       end
     end
 
@@ -135,6 +136,7 @@ class Thor
     #
     def start(original_args=ARGV, config={})
       @@original_args = original_args
+
       super do |given_args|
         meth = given_args.first.to_s
 
@@ -154,7 +156,7 @@ class Thor
           args, opts = given_args, {}
         end
 
-        task ||= Thor::Task::Dynamic.new(meth)
+        task ||= Thor::DynamicTask.new(meth)
         trailing = args[Range.new(arguments.size, -1)]
         new(args, opts, config).invoke(task, trailing || [])
       end
@@ -204,11 +206,12 @@ class Thor
     # Returns tasks ready to be printed.
     def printable_tasks(all = true, subcommand = false)
       (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
         item = []
         item << banner(task, false, subcommand)
         item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
         item
-      end
+      end.compact
     end
 
     def subcommands
@@ -239,8 +242,9 @@ class Thor
 
       def create_task(meth) #:nodoc:
         if @usage && @desc
-          tasks[meth.to_s] = Thor::Task.new(meth, @desc, @long_desc, @usage, method_options)
-          @usage, @desc, @long_desc, @method_options = nil
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth.to_s] = 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
           true

data/lib/thor/base.rb

@@ -336,6 +336,7 @@ class Thor
       def no_tasks
         @no_tasks = true
         yield
+      ensure
         @no_tasks = false
       end
 
@@ -449,7 +450,7 @@ class Thor
         def build_option(name, options, scope) #:nodoc:
           scope[name] = Thor::Option.new(name, options[:desc], options[:required],
                                                options[:type], options[:default], options[:banner],
-                                               options[:group], options[:aliases])
+                                               options[:lazy_default], options[:group], options[:aliases])
         end
 
         # Receives a hash of options, parse them and add to the scope. This is a

data/lib/thor/group.rb

@@ -233,7 +233,7 @@ class Thor::Group
 
       # Represents the whole class as a task.
       def self_task #:nodoc:
-        Thor::Task::Dynamic.new(self.namespace, class_options)
+        Thor::DynamicTask.new(self.namespace, class_options)
       end
 
       def baseclass #:nodoc:

data/lib/thor/invocation.rb

@@ -156,7 +156,7 @@ class Thor
         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 = klass.all_tasks[task.to_s] || Thor::DynamicTask.new(task) if task && !task.is_a?(Thor::Task)
         task
       end
 

data/lib/thor/parser/argument.rb

@@ -31,10 +31,10 @@ 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
 
@@ -45,21 +45,21 @@ class Thor
       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/thor/parser/option.rb

@@ -1,13 +1,14 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group
+    attr_reader :aliases, :group, :lazy_default
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
-    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, group=nil, aliases=nil)
+    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, lazy_default=nil, group=nil, aliases=nil)
       super(name, description, required, type, default, banner)
-      @aliases = [*aliases].compact
-      @group   = group.to_s.capitalize if group
+      @lazy_default = lazy_default
+      @group        = group.to_s.capitalize if group
+      @aliases      = [*aliases].compact
     end
 
     # This parse quick options given as method_options. It makes several
@@ -48,23 +49,22 @@ 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, nil, required, type, default, nil, nil, nil, aliases)
     end
 
     def switch_name
@@ -91,38 +91,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/thor/parser/options.rb

@@ -150,7 +150,7 @@ 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
           else
             raise MalformattedArgumentError, "No value provided for option '#{switch}'"
           end

data/lib/thor/task.rb

@@ -2,21 +2,6 @@ class Thor
   class Task < Struct.new(:name, :description, :long_description, :usage, :options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
-    # A dynamic task that handles method missing scenarios.
-    class Dynamic < Task
-      def initialize(name, options=nil)
-        super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
-      end
-
-      def run(instance, args=[])
-        if (instance.methods & [name.to_s, name.to_sym]).empty?
-          super
-        else
-          instance.class.handle_no_task_error(name)
-        end
-      end
-    end
-
     def initialize(name, description, long_description, usage, options=nil)
       super(name.to_s, description, long_description, usage, options || {})
     end
@@ -26,6 +11,10 @@ class Thor
       self.options = other.options.dup if other.options
     end
 
+    def hidden?
+      false
+    end
+
     # By default, a task invokes a method in the thor class. You can change this
     # implementation to create custom tasks.
     def run(instance, args=[])
@@ -42,9 +31,8 @@ class Thor
     # Returns the formatted usage by injecting given required arguments
     # and required options into the given usage.
     def formatted_usage(klass, namespace = true, subcommand = false)
-      namespace = klass.namespace unless namespace == false
-
       if namespace
+        namespace = klass.namespace
         formatted = "#{namespace.gsub(/^(default)/,'')}:"
         formatted.sub!(/.$/, ' ') if subcommand
       end
@@ -67,36 +55,60 @@ class Thor
       formatted.strip
     end
 
-    protected
+  protected
 
-      def not_debugging?(instance)
-        !(instance.class.respond_to?(:debugging) && instance.class.debugging)
-      end
+    def not_debugging?(instance)
+      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+    end
 
-      def required_options
-        @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
-      end
+    def required_options
+      @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
+    end
 
-      # Given a target, checks if this class name is not a private/protected method.
-      def public_method?(instance) #:nodoc:
-        collection = instance.private_methods + instance.protected_methods
-        (collection & [name.to_s, name.to_sym]).empty?
-      end
+    # Given a target, checks if this class name is not a private/protected method.
+    def public_method?(instance) #:nodoc:
+      collection = instance.private_methods + instance.protected_methods
+      (collection & [name.to_s, name.to_sym]).empty?
+    end
 
-      def sans_backtrace(backtrace, caller) #:nodoc:
-        saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP }
-        saned -= caller
-      end
+    def sans_backtrace(backtrace, caller) #:nodoc:
+      saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP }
+      saned -= caller
+    end
 
-      def handle_argument_error?(instance, error, caller)
-        not_debugging?(instance) && error.message =~ /wrong number of arguments/ &&
-          sans_backtrace(error.backtrace, caller).empty?
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && error.message =~ /wrong number of arguments/ && begin
+        saned = sans_backtrace(error.backtrace, caller)
+        # Ruby 1.9 always include the called method in the backtrace
+        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
       end
+    end
 
-      def handle_no_method_error?(instance, error, caller)
-        not_debugging?(instance) &&
-          error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
-      end
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) &&
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    end
+  end
 
+  # A task that is hidden in help messages but still invocable.
+  class HiddenTask < Task
+    def hidden?
+      true
+    end
+  end
+
+  # A dynamic task that handles method missing scenarios.
+  class DynamicTask < Task
+    def initialize(name, options=nil)
+      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
+    end
+
+    def run(instance, args=[])
+      if (instance.methods & [name.to_s, name.to_sym]).empty?
+        super
+      else
+        instance.class.handle_no_task_error(name)
+      end
+    end
   end
 end

data/lib/thor/version.rb

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

data/spec/fixtures/script.thor

@@ -26,6 +26,11 @@ class MyScript < Thor
     [type]
   end
 
+  desc "hidden TYPE", "this is hidden", :hide => true
+  def hidden(type)
+    [type]
+  end
+
   desc "foo BAR", <<END
 do some fooing
   This is more info!
@@ -67,6 +72,7 @@ END
   end
 
   method_options :all => :boolean
+  method_option :lazy, :lazy_default => "yes"
   desc "with_optional NAME", "invoke with optional name"
   def with_optional(name=nil)
     [ name, options ]

data/spec/parser/option_spec.rb

@@ -6,8 +6,8 @@ describe Thor::Option do
     Thor::Option.parse(key, value)
   end
 
-  def option(name, description=nil, required=false, type=nil, default=nil, banner=nil, group=nil, aliases=[])
-    @option ||= Thor::Option.new(name, description, required, type, default, banner, group, aliases)
+  def option(name, *args)
+    @option ||= Thor::Option.new(name, *args)
   end
 
   describe "#parse" do

data/spec/spec_helper.rb

@@ -10,7 +10,10 @@ require 'rdoc'
 require 'diff/lcs' # You need diff/lcs installed to run specs (but not to run Thor).
 require 'fakeweb'  # You need fakeweb installed to run specs (but not to run Thor).
 
+# Set shell to basic
+$0 = "thor"
 $thor_runner = true
+Thor::Base.shell = Thor::Shell::Basic
 
 # Load fixtures
 load File.join(File.dirname(__FILE__), "fixtures", "task.thor")
@@ -18,10 +21,6 @@ load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
 load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
 load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
 
-# Set shell to basic
-$0 = "thor"
-Thor::Base.shell = Thor::Shell::Basic
-
 Kernel.module_eval do
   alias_method :must, :should
   alias_method :must_not, :should_not

data/spec/task_spec.rb

@@ -31,16 +31,16 @@ describe Thor::Task do
 
   describe "#dynamic" do
     it "creates a dynamic task with the given name" do
-      Thor::Task::Dynamic.new('task').name.must == 'task'
-      Thor::Task::Dynamic.new('task').description.must == 'A dynamically-generated task'
-      Thor::Task::Dynamic.new('task').usage.must == 'task'
-      Thor::Task::Dynamic.new('task').options.must == {}
+      Thor::DynamicTask.new('task').name.must == 'task'
+      Thor::DynamicTask.new('task').description.must == 'A dynamically-generated task'
+      Thor::DynamicTask.new('task').usage.must == 'task'
+      Thor::DynamicTask.new('task').options.must == {}
     end
 
     it "does not invoke an existing method" do
       mock = mock()
       mock.class.should_receive(:handle_no_task_error).with("to_s")
-      Thor::Task::Dynamic.new('to_s').run(mock)
+      Thor::DynamicTask.new('to_s').run(mock)
     end
   end
 

data/spec/thor_spec.rb

@@ -8,6 +8,17 @@ describe Thor do
       options.must == { "force" => true }
     end
 
+    it "sets method_option with given parameters" do
+      arg, options = MyScript.start(["with_optional"])
+      options.must == {}
+
+      arg, options = MyScript.start(["with_optional", "--lazy"])
+      options.must == { "lazy" => "yes" }
+
+      arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
+      options.must == { "lazy" => "yesyes!" }
+    end
+
     describe "when :for is supplied" do
       it "updates an already defined task" do
         args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
@@ -66,12 +77,19 @@ describe Thor do
   end
 
   describe "#desc" do
-    before(:all) do
-      @content = capture(:stdout) { MyScript.start(["help"]) }
+    it "provides description for a task" do
+      content = capture(:stdout) { MyScript.start(["help"]) }
+      content.must =~ /thor my_script:zoo\s+# zoo around/m
     end
 
-    it "provides description for a task" do
-      @content.must =~ /zoo\s+# zoo around/m
+    it "provides no namespace if $thor_runner is false" do
+      begin
+        $thor_runner = false
+        content = capture(:stdout) { MyScript.start(["help"]) }
+        content.must =~ /thor zoo\s+# zoo around/m
+      ensure
+        $thor_runner = true
+      end
     end
 
     describe "when :for is supplied" do
@@ -79,6 +97,16 @@ describe Thor do
         capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \s+# fish around/m
       end
     end
+
+    describe "when :hide is supplied" do
+      it "does not show the task in help" do
+        capture(:stdout) { MyScript.start(["help"]) }.must_not =~ /this is hidden/m
+      end
+
+      it "but the task is still invokcable not show the task in help" do
+        MyScript.start(["hidden", "yesyes"]).must == ["yesyes"]
+      end
+    end
   end
 
   describe "#method_options" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: thor
 version: !ruby/object:Gem::Version 
-  hash: 37
+  hash: 59
   prerelease: false
   segments: 
   - 0
   - 13
-  - 7
-  version: 0.13.7
+  - 8
+  version: 0.13.8
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 +02:00
+date: 2010-07-16 00:00:00 +02:00
 default_executable: 
 dependencies: []