atli 0.1.4 → 0.1.5

data/lib/thor/command.rb

@@ -23,39 +23,102 @@ class Thor
     def hidden?
       false
     end
-
+    
+    
+    # Run a command by calling the actual method on the {Thor::Base} instance.
+    # 
     # By default, a command invokes a method in the thor class. You can change
     # this implementation to create custom commands.
-    def run(instance, args = [])
-      logger.trace "Command#run",
-        self: self,
-        instance: instance,
+    # 
+    # @param [Thor::Base] instance
+    #   Thor class instance the command is being run for.
+    # 
+    # @param [Array<?>] args
+    #   Arguments for the command.
+    # 
+    # @return
+    #   The return value of the command method on `instance`.
+    # 
+    # @raise [Thor::InvocationError]
+    #   1.  When we find a suitable method on `instance` to call, but it
+    #       raised and {ArgumentError} **and** {#handle_argument_error?}
+    #       returned `true`.
+    # 
+    def run instance, args = []
+      logger.debug "Command#run",
+        name: self.name,
         args: args
       
+      # raise "BAD!!!" unless args.include? '--'
+      
+      # Declaration for arity of the method, which is set in (2) below and
+      # used when handling raised {ArgumentError}
       arity = nil
-
-      if private_method?(instance)
-        instance.class.handle_no_command_error(name)
-      elsif public_method?(instance)
-        arity = instance.method(name).arity
-        instance.__send__(name, *args)
-      elsif local_method?(instance, :method_missing)
-        instance.__send__(:method_missing, name.to_sym, *args)
+      
+      # Method invocation switch - figure out how to make the method call to
+      # `instance`, or error out.
+      # 
+      # Cases:
+      # 
+      # 1.  Protect from calling private methods by error'ing out if {#name}
+      #     is the name of a private method of `instance`.
+      #     
+      if private_method? instance
+        instance.class.handle_no_command_error name
+      
+      # 2.  The success case - if {#name} is a public method of `instance`
+      #     than call it with `args`.
+      #     
+      elsif public_method? instance
+        # Save the arity to use when handling {ArgumentError} below
+        # 
+        # TODO  Why does it fetch the {Method} *then* use {#__send__} instead
+        #       of just `#call` it?
+        #       
+        arity = instance.method( name ).arity
+        
+        # Unless the method is a subcommand, remove any '--' separators
+        # since we know we're done option parsin'
+        unless subcommand? instance, name
+          args = args.reject { |arg| arg == '--' }
+        end
+        
+        # Do that call
+        instance.__send__ name, *args
+      
+      # 3.  If the {Thor} instance has a `#method_missing` defined in *itself*
+      #     (not any super class) than call that.
+      #     
+      elsif local_method? instance, :method_missing
+        instance.__send__ :method_missing, name.to_sym, *args
+      
+      # 4.  We got nothing... pass of to
+      #     {Thor::Base::ClassMethods.handle_no_command_error}
+      #     which will raise.
+      #     
       else
-        instance.class.handle_no_command_error(name)
-      end
-    rescue ArgumentError => e
-      if handle_argument_error?(instance, e, caller)
-        instance.class.handle_argument_error(self, e, args, arity)
+        instance.class.handle_no_command_error name
+      
+      end # Method invocation switch
+      
+    rescue ArgumentError => error
+      if handle_argument_error? instance, error, caller
+        # NOTE  I *believe* `arity` could still be `nil`, assuming that
+        #       (3) could raise {ArgumentError} and end up here.
+        #       
+        #       However...
+        instance.class.handle_argument_error self, error, args, arity
       else
-        raise e
+        raise error
       end
-    rescue NoMethodError => e
-      if handle_no_method_error?(instance, e, caller)
-        instance.class.handle_no_command_error(name)
+    
+    rescue NoMethodError => error
+      if handle_no_method_error? instance, error, caller
+        instance.class.handle_no_command_error name
       else
-        raise e
+        raise error
       end
+    
     rescue Exception => error
       # NOTE  Need to use `#__send__` because the instance may define a
       #       command (method) `#send` - and one of the test fixtures **does**:
@@ -73,7 +136,8 @@ class Thor
       
       # If you want something done right...
       raise error
-    end
+    end # #run
+    
 
     # Returns the formatted usage by injecting given required arguments
     # and required options into the given usage.
@@ -125,22 +189,76 @@ class Thor
         sort.
         join(" ")
     end
-
-    # Given a target, checks if this class name is a public method.
+    
+    
+    
+    # Is `name` a subcommand of `instance`?
+    # 
+    # @param [Thor::Base] instance
+    #   The Thor instance this command is being run for.
+    # 
+    # @param [Symbol | String] name
+    #   The subcommand / method name.
+    # 
+    # @return [return_type]
+    #   @todo Document return value.
+    # 
+    def subcommand? instance, name
+      # It doesn't look like {Thor::Group} has `.subcommands`, so test for
+      # that first.
+      return false unless instance.class.respond_to?( :subcommands )
+      
+      # See if the names is in the subcommands
+      instance.class.subcommands.include? name.to_s
+    end # #subcommand?
+    
+    
+    
+    # Is this command's {#name} a public method of `instance`?
+    # 
+    # @param [Thor::Base] instance
+    #   The Thor instance this command is being run for.
+    # 
+    # @return [Boolean]
+    #   `true` if {#name} is a public method of `instance`.
+    # 
     def public_method?(instance) #:nodoc:
       !(instance.public_methods & [name.to_s, name.to_sym]).empty?
     end
-
+    
+    
+    # Is this command's {#name} a private method of `instance`?
+    # 
+    # @param [Thor::Base] instance
+    #   The Thor instance this command is being run for.
+    # 
+    # @return [Boolean]
+    #   `true` if {#name} is a private method of `instance`.
+    # 
     def private_method?(instance)
       !(instance.private_methods & [name.to_s, name.to_sym]).empty?
     end
-
+    
+    
+    # Is `name` the name of a method defined in `instance` itself (not
+    # any super class)?
+    # 
+    # @param [Thor::Base] instance
+    #   The Thor instance this command is being run for.
+    # 
+    # @param [Symbol | String] name
+    #   The method name.
+    # 
+    # @return [Boolean]
+    #   `true` if `name` is the name of a method defined in `instance` itself.
+    # 
     def local_method?(instance, name)
       methods = instance.public_methods(false) +
                 instance.private_methods(false) +
                 instance.protected_methods(false)
       !(methods & [name.to_s, name.to_sym]).empty?
     end
+    
 
     def sans_backtrace(backtrace, caller) #:nodoc:
       saned = backtrace.reject { |frame|

data/lib/thor/group.rb

@@ -203,7 +203,7 @@ class Thor::Group
       [item]
     end
     alias_method :printable_tasks, :printable_commands
-
+    
     def handle_argument_error(command, error, _args, arity) #:nodoc:
       msg = "#{basename} #{command.name} takes #{arity} argument".dup
       msg << "s" if arity > 1
@@ -211,71 +211,78 @@ class Thor::Group
       raise error, msg
     end
 
-  protected
-
-    # The method responsible for dispatching given the args.
-    def dispatch(command, given_args, given_opts, config) #:nodoc:
-      if Thor::HELP_MAPPINGS.include?(given_args.first)
-        help(config[:shell])
-        return
-      end
+    protected
+    # ============================================================================
+    
+      # The method responsible for dispatching given the args.
+      def dispatch(command, 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
+        args, opts = Thor::Options.split(given_args)
+        opts = given_opts || opts
 
-      instance = new(args, opts, config)
-      yield instance if block_given?
+        instance = new(args, opts, config)
+        yield instance if block_given?
 
-      if command
-        instance.invoke_command(all_commands[command])
-      else
-        instance.invoke_all
+        if command
+          instance.invoke_command(all_commands[command])
+        else
+          instance.invoke_all
+        end
       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
-      "#{basename} #{self_command.formatted_usage(self, false)}"
-    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
+        "#{basename} #{self_command.formatted_usage(self, false)}"
+      end
 
-    # Represents the whole class as a command.
-    def self_command #:nodoc:
-      Thor::DynamicCommand.new(namespace, class_options)
-    end
-    alias_method :self_task, :self_command
+      # Represents the whole class as a command.
+      def self_command #:nodoc:
+        Thor::DynamicCommand.new(namespace, class_options)
+      end
+      alias_method :self_task, :self_command
 
-    def baseclass #:nodoc:
-      Thor::Group
-    end
+      def baseclass #:nodoc:
+        Thor::Group
+      end
 
-    def create_command(meth) #:nodoc:
-      commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
-      true
-    end
-    alias_method :create_task, :create_command
-  end
+      def create_command(meth) #:nodoc:
+        commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
+        true
+      end
+      alias_method :create_task, :create_command
+    
+    public # end protected ***************************************************
+  
+  end # class << self ********************************************************
 
   include Thor::Base
 
-protected
-
-  # Shortcut to invoke with padding and block handling. Use internally by
-  # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, command = nil, *args, &block) #:nodoc:
-    with_padding do
-      if block
-        case block.arity
-        when 3
-          yield(self, klass, command)
-        when 2
-          yield(self, klass)
-        when 1
-          instance_exec(klass, &block)
+  protected
+  # ==========================================================================
+
+    # Shortcut to invoke with padding and block handling. Use internally by
+    # invoke and invoke_from_option class methods.
+    def _invoke_for_class_method(klass, command = nil, *args, &block) #:nodoc:
+      with_padding do
+        if block
+          case block.arity
+          when 3
+            yield(self, klass, command)
+          when 2
+            yield(self, klass)
+          when 1
+            instance_exec(klass, &block)
+          end
+        else
+          invoke klass, command, *args
         end
-      else
-        invoke klass, command, *args
       end
     end
-  end
+  
+  public # end protected *****************************************************
 end

data/lib/thor/parser/argument.rb

@@ -44,8 +44,15 @@ class Thor
   protected
 
     def validate!
-      raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
-      raise ArgumentError, "An argument cannot have an enum other than an array." if @enum && !@enum.is_a?(Array)
+      if required? && !default.nil?
+        raise ArgumentError,
+          "An argument cannot be required and have default value."
+      end
+      
+      if @enum && !@enum.is_a?(Array)
+        raise ArgumentError,
+          "An argument cannot have an enum other than an array."
+      end
     end
 
     def valid_type?(type)

data/lib/thor/parser/arguments.rb

@@ -1,5 +1,7 @@
 class Thor
-  class Arguments #:nodoc: # rubocop:disable ClassLength
+  class Arguments # rubocop:disable ClassLength
+    include SemanticLogger::Loggable
+    
     NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
@@ -36,140 +38,170 @@ class Thor
         end
       end
     end
+    
 
-    def parse(args)
+    def parse args
+      logger.debug __method__.to_s,
+        args: args
+      
       @pile = args.dup
 
       @switches.each do |argument|
         break unless peek
         @non_assigned_required.delete(argument)
-        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
+        @assigns[argument.human_name] = send  :"parse_#{argument.type}",
+                                              argument.human_name
       end
 
       check_requirement!
       @assigns
     end
+    
 
     def remaining
       @pile
     end
+    
+    
+    private # Instance Methods
+    # ========================================================================
 
-  private
-
-    def no_or_skip?(arg)
-      arg =~ /^--(no|skip)-([-\w]+)$/
-      $2
-    end
-
-    def last?
-      @pile.empty?
-    end
-
-    def peek
-      @pile.first
-    end
-
-    def shift
-      @pile.shift
-    end
-
-    def unshift(arg)
-      if arg.is_a?(Array)
-        @pile = arg + @pile
-      else
-        @pile.unshift(arg)
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
       end
-    end
-
-    def current_is_value?
-      peek && peek.to_s !~ /^-/
-    end
-
-    # Runs through the argument array getting strings that contains ":" and
-    # mark it as a hash:
-    #
-    #   [ "name:string", "age:integer" ]
-    #
-    # Becomes:
-    #
-    #   { "name" => "string", "age" => "integer" }
-    #
-    def parse_hash(name)
-      return shift if peek.is_a?(Hash)
-      hash = {}
-
-      while current_is_value? && peek.include?(":")
-        key, value = shift.split(":", 2)
-        raise MalformattedArgumentError, "You can't specify '#{key}' more than once in option '#{name}'; got #{key}:#{hash[key]} and #{key}:#{value}" if hash.include? key
-        hash[key] = value
+      
+      
+      def last?
+        @pile.empty?
       end
-      hash
-    end
-
-    # Runs through the argument array getting all strings until no string is
-    # found or a switch is found.
-    #
-    #   ["a", "b", "c"]
-    #
-    # And returns it as an array:
-    #
-    #   ["a", "b", "c"]
-    #
-    def parse_array(name)
-      return shift if peek.is_a?(Array)
-      array = []
-      array << shift while current_is_value?
-      array
-    end
-
-    # Check if the peek is numeric format and return a Float or Integer.
-    # Check if the peek is included in enum if enum is provided.
-    # Otherwise raises an error.
-    #
-    def parse_numeric(name)
-      return shift if peek.is_a?(Numeric)
-
-      unless peek =~ NUMERIC && $& == peek
-        raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
+      
+      
+      def peek
+        @pile.first
       end
-
-      value = $&.index(".") ? shift.to_f : shift.to_i
-      if @switches.is_a?(Hash) && switch = @switches[name]
-        if switch.enum && !switch.enum.include?(value)
-          raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+      
+      
+      def shift
+        @pile.shift
+      end
+      
+      
+      def unshift(arg)
+        if arg.is_a?(Array)
+          @pile = arg + @pile
+        else
+          @pile.unshift(arg)
         end
       end
-      value
-    end
+      
+      
+      def current_is_value?
+        peek && peek.to_s !~ /^-/
+      end
+      
+      
+      # Runs through the argument array getting strings that contains ":" and
+      # mark it as a hash:
+      #
+      #   [ "name:string", "age:integer" ]
+      #
+      # Becomes:
+      #
+      #   { "name" => "string", "age" => "integer" }
+      #
+      def parse_hash(name)
+        return shift if peek.is_a?(Hash)
+        hash = {}
+
+        while current_is_value? && peek.include?(":")
+          key, value = shift.split(":", 2)
+          if hash.include? key
+            raise MalformattedArgumentError,
+              "You can't specify '#{key}' more than once in option " \
+              "'#{name}'; got #{key}:#{hash[key]} and #{key}:#{value}"
+          end
+          hash[key] = value
+        end
+        hash
+      end
+      
+      
+      # Runs through the argument array getting all strings until no string is
+      # found or a switch is found.
+      #
+      #   ["a", "b", "c"]
+      #
+      # And returns it as an array:
+      #
+      #   ["a", "b", "c"]
+      #
+      def parse_array(name)
+        return shift if peek.is_a?(Array)
+        array = []
+        array << shift while current_is_value?
+        array
+      end
+      
+      
+      # Check if the peek is numeric format and return a Float or Integer.
+      # Check if the peek is included in enum if enum is provided.
+      # Otherwise raises an error.
+      #
+      def parse_numeric(name)
+        return shift if peek.is_a?(Numeric)
+
+        unless peek =~ NUMERIC && $& == peek
+          raise MalformattedArgumentError,
+            "Expected numeric value for '#{name}'; got #{peek.inspect}"
+        end
 
-    # Parse string:
-    # for --string-arg, just return the current value in the pile
-    # for --no-string-arg, nil
-    # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
-    #
-    def parse_string(name)
-      if no_or_skip?(name)
-        nil
-      else
-        value = shift
+        value = $&.index(".") ? shift.to_f : shift.to_i
         if @switches.is_a?(Hash) && switch = @switches[name]
           if switch.enum && !switch.enum.include?(value)
-            raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+            raise MalformattedArgumentError,
+              "Expected '#{name}' to be one of #{switch.enum.join(', ')}; " \
+              "got #{value}"
           end
         end
         value
       end
-    end
-
-    # Raises an error if @non_assigned_required array is not empty.
-    #
-    def check_requirement!
-      return if @non_assigned_required.empty?
-      names = @non_assigned_required.map do |o|
-        o.respond_to?(:switch_name) ? o.switch_name : o.human_name
-      end.join("', '")
-      class_name = self.class.name.split("::").last.downcase
-      raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
-    end
-  end
-end
+      
+      
+      # Parse string:
+      # for --string-arg, just return the current value in the pile
+      # for --no-string-arg, nil
+      # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
+      #
+      def parse_string(name)
+        if no_or_skip?(name)
+          nil
+        else
+          value = shift
+          if @switches.is_a?(Hash) && switch = @switches[name]
+            if switch.enum && !switch.enum.include?(value)
+              raise MalformattedArgumentError,
+                "Expected '#{name}' to be one of #{switch.enum.join(', ')}; " \
+                "got #{value}"
+            end
+          end
+          value
+        end
+      end
+      
+      
+      # Raises an error if @non_assigned_required array is not empty.
+      #
+      def check_requirement!
+        return if @non_assigned_required.empty?
+        names = @non_assigned_required.map do |o|
+          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+        end.join("', '")
+        class_name = self.class.name.split("::").last.downcase
+        raise RequiredArgumentMissingError,
+          "No value provided for required #{class_name} '#{names}'"
+      end
+    
+    public # end private Instance Methods ************************************
+  end # class Arguments
+end # class Thor