thor 0.16.0 → 1.2.1

data/lib/thor/parser/options.rb

@@ -1,31 +1,37 @@
 class Thor
-  class Options < Arguments #:nodoc:
+  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
     LONG_RE     = /^(--\w+(?:-\w+)*)$/
     SHORT_RE    = /^(-[a-z])$/i
     EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
     SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
     SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+    OPTS_END    = "--".freeze
 
     # Receives a hash and makes it switches.
     def self.to_switches(options)
       options.map do |key, value|
         case value
-          when true
-            "--#{key}"
-          when Array
-            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
-          when Hash
-            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
-          when nil, false
-            ""
-          else
-            "--#{key} #{value.inspect}"
+        when true
+          "--#{key}"
+        when Array
+          "--#{key} #{value.map(&:inspect).join(' ')}"
+        when Hash
+          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
+        when nil, false
+          nil
+        else
+          "--#{key} #{value.inspect}"
         end
-      end.join(" ")
+      end.compact.join(" ")
     end
 
     # Takes a hash of Thor::Option and a hash with defaults.
-    def initialize(hash_options={}, defaults={})
+    #
+    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+    # an unknown option or a regular argument.
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false)
+      @stop_on_unknown = stop_on_unknown
+      @disable_required_check = disable_required_check
       options = hash_options.values
       super(options)
 
@@ -35,13 +41,18 @@ class Thor
         @non_assigned_required.delete(hash_options[key])
       end
 
-      @shorts, @switches, @extra = {}, {}, []
+      @shorts = {}
+      @switches = {}
+      @extra = []
+      @stopped_parsing_after_extra_index = nil
+      @is_treated_as_value = false
 
       options.each do |option|
         @switches[option.switch_name] = option
 
         option.aliases.each do |short|
-          @shorts[short.to_s] ||= option.switch_name
+          name = short.to_s.sub(/^(?!\-)/, "-")
+          @shorts[name] ||= option.switch_name
         end
       end
     end
@@ -50,37 +61,77 @@ class Thor
       @extra
     end
 
-    def parse(args)
+    def peek
+      return super unless @parsing_options
+
+      result = super
+      if result == OPTS_END
+        shift
+        @parsing_options = false
+        @stopped_parsing_after_extra_index ||= @extra.size
+        super
+      else
+        result
+      end
+    end
+
+    def shift
+      @is_treated_as_value = false
+      super
+    end
+
+    def unshift(arg, is_value: false)
+      @is_treated_as_value = is_value
+      super(arg)
+    end
+
+    def parse(args) # rubocop:disable MethodLength
       @pile = args.dup
+      @is_treated_as_value = false
+      @parsing_options = true
 
       while peek
-        match, is_switch = current_is_switch?
-        shifted = shift
+        if parsing_options?
+          match, is_switch = current_is_switch?
+          shifted = shift
 
-        if is_switch
-          case shifted
+          if is_switch
+            case shifted
             when SHORT_SQ_RE
-              unshift($1.split('').map { |f| "-#{f}" })
+              unshift($1.split("").map { |f| "-#{f}" })
               next
-            when EQ_RE, SHORT_NUM
+            when EQ_RE
+              unshift($2, is_value: true)
+              switch = $1
+            when SHORT_NUM
               unshift($2)
               switch = $1
             when LONG_RE, SHORT_RE
               switch = $1
+            end
+
+            switch = normalize_switch(switch)
+            option = switch_option(switch)
+            result = parse_peek(switch, option)
+            assign_result!(option, result)
+          elsif @stop_on_unknown
+            @parsing_options = false
+            @extra << shifted
+            @stopped_parsing_after_extra_index ||= @extra.size
+            @extra << shift while peek
+            break
+          elsif match
+            @extra << shifted
+            @extra << shift while peek && peek !~ /^-/
+          else
+            @extra << shifted
           end
-
-          switch = normalize_switch(switch)
-          option = switch_option(switch)
-          @assigns[option.human_name] = parse_peek(switch, option)
-        elsif match
-          @extra << shifted
-          @extra << shift while peek && peek !~ /^-/
         else
-          @extra << shifted
+          @extra << shift
         end
       end
 
-      check_requirement!
+      check_requirement! unless @disable_required_check
 
       assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
       assigns.freeze
@@ -88,91 +139,117 @@ class Thor
     end
 
     def check_unknown!
+      to_check = @stopped_parsing_after_extra_index ? @extra[0...@stopped_parsing_after_extra_index] : @extra
+
       # an unknown option starts with - or -- and has no more --'s afterward.
-      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+      unknown = to_check.select { |str| str =~ /^--?(?:(?!--).)*$/ }
+      raise UnknownArgumentError.new(@switches.keys, unknown) unless unknown.empty?
     end
 
-    protected
+  protected
 
-      # Returns true if the current value in peek is a registered switch.
-      #
-      def current_is_switch?
-        case peek
-        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
+    def assign_result!(option, result)
+      if option.repeatable && option.type == :hash
+        (@assigns[option.human_name] ||= {}).merge!(result)
+      elsif option.repeatable
+        (@assigns[option.human_name] ||= []) << result
+      else
+        @assigns[option.human_name] = result
       end
+    end
 
-      def current_is_switch_formatted?
-        case peek
-        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
-          true
-        else
-          false
-        end
+    # Check if the current value in peek is a registered switch.
+    #
+    # Two booleans are returned.  The first is true if the current value
+    # starts with a hyphen; the second is true if it is a registered switch.
+    def current_is_switch?
+      return [false, false] if @is_treated_as_value
+      case peek
+      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?(arg)
-        switch_option(normalize_switch(arg))
+    def current_is_switch_formatted?
+      return false if @is_treated_as_value
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+        true
+      else
+        false
       end
+    end
 
-      def switch_option(arg)
-        if match = no_or_skip?(arg)
-          @switches[arg] || @switches["--#{match}"]
-        else
-          @switches[arg]
-        end
-      end
+    def current_is_value?
+      return true if @is_treated_as_value
+      peek && (!parsing_options? || super)
+    end
+
+    def switch?(arg)
+      !switch_option(normalize_switch(arg)).nil?
+    end
 
-      # Check if the given argument is actually a shortcut.
-      #
-      def normalize_switch(arg)
-        (@shorts[arg] || arg).tr('_', '-')
+    def switch_option(arg)
+      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
+        @switches[arg] || @switches["--#{match}"]
+      else
+        @switches[arg]
       end
+    end
 
-      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
-      #
-      def parse_boolean(switch)
-        if current_is_value?
-          if ["true", "TRUE", "t", "T", true].include?(peek)
-            shift
-            true
-          elsif ["false", "FALSE", "f", "F", false].include?(peek)
-            shift
-            false
-          else
-            true
-          end
+    # Check if the given argument is actually a shortcut.
+    #
+    def normalize_switch(arg)
+      (@shorts[arg] || arg).tr("_", "-")
+    end
+
+    def parsing_options?
+      peek
+      @parsing_options
+    end
+
+    # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+    #
+    def parse_boolean(switch)
+      if current_is_value?
+        if ["true", "TRUE", "t", "T", true].include?(peek)
+          shift
+          true
+        elsif ["false", "FALSE", "f", "F", false].include?(peek)
+          shift
+          false
         else
           @switches.key?(switch) || !no_or_skip?(switch)
         end
+      else
+        @switches.key?(switch) || !no_or_skip?(switch)
       end
+    end
 
-      # Parse the value at the peek analyzing if it requires an input or not.
-      #
-      def parse_peek(switch, option)
-        if current_is_switch_formatted? || last?
-          if option.boolean?
-            # No problem for boolean types
-          elsif no_or_skip?(switch)
-            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.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
+    # Parse the value at the peek analyzing if it requires an input or not.
+    #
+    def parse_peek(switch, option)
+      if parsing_options? && (current_is_switch_formatted? || last?)
+        if option.boolean?
+          # No problem for boolean types
+        elsif no_or_skip?(switch)
+          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.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
-
-        @non_assigned_required.delete(option)
-        send(:"parse_#{option.type}", switch)
       end
+
+      @non_assigned_required.delete(option)
+      send(:"parse_#{option.type}", switch)
+    end
   end
 end

data/lib/thor/parser.rb

@@ -1,4 +1,4 @@
-require 'thor/parser/argument'
-require 'thor/parser/arguments'
-require 'thor/parser/option'
-require 'thor/parser/options'
+require_relative "parser/argument"
+require_relative "parser/arguments"
+require_relative "parser/option"
+require_relative "parser/options"

data/lib/thor/rake_compat.rb

@@ -1,17 +1,18 @@
-require 'rake'
-require 'rake/dsl_definition'
+require "rake"
+require "rake/dsl_definition"
 
 class Thor
   # Adds a compatibility layer to your Thor classes which allows you to use
   # rake package tasks. For example, to use rspec rake tasks, one can do:
   #
   #   require 'thor/rake_compat'
+  #   require 'rspec/core/rake_task'
   #
   #   class Default < Thor
   #     include Thor::RakeCompat
   #
-  #     Spec::Rake::SpecTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', "spec/spec.opts"]
+  #     RSpec::Core::RakeTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', './.rspec']
   #       t.spec_files = FileList['spec/**/*_spec.rb']
   #     end
   #   end
@@ -24,26 +25,27 @@ class Thor
     end
 
     def self.included(base)
+      super(base)
       # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
       rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
       Rake.application.instance_variable_set(:@rakefile, rakefile)
-      self.rake_classes << base
+      rake_classes << base
     end
   end
 end
 
 # override task on (main), for compatibility with Rake 0.9
-self.instance_eval do
+instance_eval do
   alias rake_namespace namespace
 
   def task(*)
     task = super
 
-    if klass = Thor::RakeCompat.rake_classes.last
-      non_namespaced_name = task.name.split(':').last
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
+      non_namespaced_name = task.name.split(":").last
 
       description = non_namespaced_name
-      description << task.arg_names.map{ |n| n.to_s.upcase }.join(' ')
+      description << task.arg_names.map { |n| n.to_s.upcase }.join(" ")
       description.strip!
 
       klass.desc description, Rake.application.last_description || non_namespaced_name
@@ -57,7 +59,7 @@ self.instance_eval do
   end
 
   def namespace(name)
-    if klass = Thor::RakeCompat.rake_classes.last
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
       const_name = Thor::Util.camel_case(name.to_s).to_sym
       klass.const_set(const_name, Class.new(Thor))
       new_klass = klass.const_get(const_name)
@@ -68,4 +70,3 @@ self.instance_eval do
     Thor::RakeCompat.rake_classes.pop
   end
 end
-