thor 0.13.4 → 0.14.3

data/lib/thor/group.rb

@@ -6,7 +6,7 @@ require 'thor/base'
 # tasks.
 class Thor::Group
   class << self
-    # The descrition for this Thor::Group. If none is provided, but a source root
+    # The description for this Thor::Group. If none is provided, but a source root
     # exists, tries to find the USAGE one folder above it, otherwise searches
     # in the superclass.
     #
@@ -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
@@ -129,7 +114,7 @@ class Thor::Group
 
       names.each do |name|
         unless class_options.key?(name)
-          raise ArgumentError, "You have to define the option #{name.inspect} " << 
+          raise ArgumentError, "You have to define the option #{name.inspect} " <<
                                "before setting invoke_from_option."
         end
 
@@ -225,15 +210,32 @@ 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
-        "#{banner_base} #{self_task.formatted_usage(self, false)}"
+        "#{basename} #{self_task.formatted_usage(self, false)}"
       end
 
       # 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:
@@ -241,7 +243,7 @@ class Thor::Group
       end
 
       def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil)
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
         true
       end
   end

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)
-          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::Task::Dynamic.new(task) if task && !task.is_a?(Thor::Task)
-        task
       end
 
       # Initialize klass using values stored in the @_initializer.
-      def _initialize_klass_with_initializer(object, args, opts, config) #:nodoc:
-        if object.is_a?(Class)
-          klass = object
+      def _parse_initialization_options(args, opts, config) #:nodoc:
+        stored_args, stored_opts, stored_config = @_initializer
 
-          stored_args, stored_opts, stored_config = @_initializer
-          args ||= stored_args.dup
-          opts ||= stored_opts.dup
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
 
-          config ||= {}
-          config = stored_config.merge(_shared_configuration).merge!(config)
-          [ klass, klass.new(args, opts, config) ]
-        else
-          [ object.class, object ]
-        end
+        config ||= {}
+        config = stored_config.merge(_shared_configuration).merge!(config)
+
+        [ args, opts, config ]
       end
   end
 end

data/lib/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/arguments.rb

@@ -51,6 +51,11 @@ class Thor
 
     private
 
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
       def last?
         @pile.empty?
       end
@@ -114,7 +119,7 @@ class Thor
         array
       end
 
-      # Check if the peel is numeric ofrmat and return a Float or Integer.
+      # Check if the peek is numeric format and return a Float or Integer.
       # Otherwise raises an error.
       #
       def parse_numeric(name)
@@ -127,10 +132,16 @@ class Thor
         $&.index('.') ? shift.to_f : shift.to_i
       end
 
-      # Parse string, i.e., just return the current value in the pile.
+      # Parse string:
+      # for --string-arg, just return the current value in the pile
+      # for --no-string-arg, nil
       #
       def parse_string(name)
-        shift
+        if no_or_skip?(name)
+          nil
+        else
+          shift
+        end
       end
 
       # Raises an error if @non_assigned_required array is not empty.

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

@@ -53,7 +53,9 @@ class Thor
       @pile = args.dup
 
       while peek
-        if current_is_switch?
+        match, is_switch = current_is_switch?
+
+        if is_switch
           case shift
             when SHORT_SQ_RE
               unshift($1.split('').map { |f| "-#{f}" })
@@ -68,7 +70,7 @@ class Thor
           switch = normalize_switch(switch)
           option = switch_option(switch)
           @assigns[option.human_name] = parse_peek(switch, option)
-        elsif current_is_switch_formatted?
+        elsif match
           @unknown << shift
         else
           shift
@@ -92,15 +94,17 @@ class Thor
       #
       def current_is_switch?
         case peek
-          when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-            switch?($1)
-          when SHORT_SQ_RE
-            $1.split('').any? { |f| switch?("-#{f}") }
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+          [true, switch?($1)]
+        when SHORT_SQ_RE
+          [true, $1.split('').any? { |f| switch?("-#{f}") }]
+        else
+          [false, false]
         end
       end
 
-      def switch_formatted?(arg)
-        case arg
+      def current_is_switch_formatted?
+        case peek
         when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
           true
         else
@@ -108,12 +112,8 @@ class Thor
         end
       end
 
-      def current_is_switch_formatted?
-        switch_formatted? peek
-      end
-
       def switch?(arg)
-        switch_option(arg) || @shorts.key?(arg)
+        switch_option(normalize_switch(arg))
       end
 
       def switch_option(arg)
@@ -124,22 +124,25 @@ class Thor
         end
       end
 
-      def no_or_skip?(arg)
-        arg =~ /^--(no|skip)-([-\w]+)$/
-        $2
-      end
-
       # Check if the given argument is actually a shortcut.
       #
       def normalize_switch(arg)
-        @shorts.key?(arg) ? @shorts[arg] : arg
+        (@shorts[arg] || arg).tr('_', '-')
       end
 
       # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
       #
       def parse_boolean(switch)
         if current_is_value?
-          ["true", "TRUE", "t", "T", true].include?(shift)
+          if ["true", "TRUE", "t", "T", true].include?(peek)
+            shift
+            true
+          elsif ["false", "FALSE", "f", "F", false].include?(peek)
+            shift
+            false
+          else
+            true
+          end
         else
           @switches.key?(switch) || !no_or_skip?(switch)
         end
@@ -155,7 +158,9 @@ class Thor
             return nil # User set value to nil
           elsif option.string? && !option.required?
             # Return the default if there is one, else the human name
-            return option.default || option.human_name
+            return option.lazy_default || option.default || option.human_name
+          elsif option.lazy_default
+            return option.lazy_default
           else
             raise MalformattedArgumentError, "No value provided for option '#{switch}'"
           end
@@ -164,6 +169,5 @@ class Thor
         @non_assigned_required.delete(option)
         send(:"parse_#{option.type}", switch)
       end
-
   end
 end

data/lib/thor/runner.rb

@@ -13,10 +13,10 @@ class Thor::Runner < Thor #:nodoc:
 
   # Override Thor#help so it can give information about any class and any method.
   #
-  def help(meth=nil)
+  def help(meth = nil)
     if meth && !self.respond_to?(meth)
       initialize_thorfiles(meth)
-      klass, task = Thor::Util.find_class_and_task_by_namespace!(meth)
+      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
       klass.start(["-h", task].compact, :shell => self.shell)
     else
       super
@@ -29,7 +29,7 @@ class Thor::Runner < Thor #:nodoc:
   def method_missing(meth, *args)
     meth = meth.to_s
     initialize_thorfiles(meth)
-    klass, task = Thor::Util.find_class_and_task_by_namespace!(meth)
+    klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
     args.unshift(task) if task
     klass.start(args, :shell => self.shell)
   end
@@ -39,15 +39,15 @@ class Thor::Runner < Thor #:nodoc:
   def install(name)
     initialize_thorfiles
 
-    # If a directory name is provided as the argument, look for a 'main.thor' 
+    # If a directory name is provided as the argument, look for a 'main.thor'
     # task in said directory.
     begin
       if File.directory?(File.expand_path(name))
         base, package = File.join(name, "main.thor"), :directory
-        contents      = open(base).read
+        contents      = open(base) {|input| input.read }
       else
         base, package = name, :file
-        contents      = open(name).read
+        contents      = open(name) {|input| input.read }
       end
     rescue OpenURI::HTTPError
       raise Error, "Error opening URI '#{name}'"
@@ -139,7 +139,7 @@ class Thor::Runner < Thor #:nodoc:
   end
 
   desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
-  method_options :substring => :boolean, :group => :string, :all => :boolean
+  method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
   def list(search="")
     initialize_thorfiles
 
@@ -156,8 +156,8 @@ class Thor::Runner < Thor #:nodoc:
 
   private
 
-    def self.banner(task)
-      "thor " + task.formatted_usage(self, false)
+    def self.banner(task, all = false, subcommand = false)
+      "thor " + task.formatted_usage(self, all, subcommand)
     end
 
     def thor_root
@@ -199,7 +199,7 @@ class Thor::Runner < Thor #:nodoc:
     #
     def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
       thorfiles(relevant_to, skip_lookup).each do |f|
-        Thor::Util.load_thorfile(f) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
+        Thor::Util.load_thorfile(f, nil, options[:debug]) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
       end
     end
 
@@ -267,16 +267,11 @@ class Thor::Runner < Thor #:nodoc:
       raise Error, "No Thor tasks available" if klasses.empty?
       show_modules if with_modules && !thor_yaml.empty?
 
-      # Remove subclasses
-      klasses.dup.each do |klass|
-        klasses -= Thor::Util.thor_classes_in(klass)
-      end
-
       list = Hash.new { |h,k| h[k] = [] }
       groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
       # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace] += k.printable_tasks(false) }
+      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
 
       # Get classes which inherit from Thor::Base
       groups.map! { |k| k.printable_tasks(false).first }