thor 0.16.0 → 1.2.1

data/lib/thor/parser/arguments.rb

@@ -1,6 +1,6 @@
 class Thor
-  class Arguments #:nodoc:
-    NUMERIC = /(\d*\.\d+|\d+)/
+  class Arguments #:nodoc: # rubocop:disable ClassLength
+    NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
     # and one with switches.
@@ -9,11 +9,11 @@ class Thor
       arguments = []
 
       args.each do |item|
-        break if item =~ /^-/
+        break if item.is_a?(String) && item =~ /^-/
         arguments << item
       end
 
-      return arguments, args[Range.new(arguments.size, -1)]
+      [arguments, args[Range.new(arguments.size, -1)]]
     end
 
     def self.parse(*args)
@@ -23,13 +23,18 @@ class Thor
 
     # Takes an array of Thor::Argument objects.
     #
-    def initialize(arguments=[])
-      @assigns, @non_assigned_required = {}, []
+    def initialize(arguments = [])
+      @assigns = {}
+      @non_assigned_required = []
       @switches = arguments
 
       arguments.each do |argument|
-        if argument.default != nil
-          @assigns[argument.human_name] = argument.default
+        if !argument.default.nil?
+          begin
+            @assigns[argument.human_name] = argument.default.dup
+          rescue TypeError  # Compatibility shim for un-dup-able Fixnum in Ruby < 2.4
+            @assigns[argument.human_name] = argument.default
+          end
         elsif argument.required?
           @non_assigned_required << argument
         end
@@ -53,119 +58,122 @@ class Thor
       @pile
     end
 
-    private
-
-      def no_or_skip?(arg)
-        arg =~ /^--(no|skip)-([-\w]+)$/
-        $2
-      end
+  private
 
-      def last?
-        @pile.empty?
-      end
+    def no_or_skip?(arg)
+      arg =~ /^--(no|skip)-([-\w]+)$/
+      $2
+    end
 
-      def peek
-        @pile.first
-      end
+    def last?
+      @pile.empty?
+    end
 
-      def shift
-        @pile.shift
-      end
+    def peek
+      @pile.first
+    end
 
-      def unshift(arg)
-        unless arg.kind_of?(Array)
-          @pile.unshift(arg)
-        else
-          @pile = arg + @pile
-        end
-      end
+    def shift
+      @pile.shift
+    end
 
-      def current_is_value?
-        peek && peek.to_s !~ /^-/
+    def unshift(arg)
+      if arg.is_a?(Array)
+        @pile = arg + @pile
+      else
+        @pile.unshift(arg)
       end
+    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)
-          hash[key] = value
-        end
-        hash
-      end
+    def current_is_value?
+      peek && peek.to_s !~ /^-{1,2}\S+/
+    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 = []
-
-        while current_is_value?
-          array << shift
-        end
-        array
+    # 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
       end
+      hash
+    end
 
-      # Check if the peek is numeric format and return a Float or Integer.
-      # Otherwise raises an error.
-      #
-      def parse_numeric(name)
-        return shift if peek.is_a?(Numeric)
+    # 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
 
-        unless peek =~ NUMERIC && $& == peek
-          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
-        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)
 
-        $&.index('.') ? shift.to_f : shift.to_i
+      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
-      #
-      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
+      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}"
         end
       end
+      value
+    end
 
-      # Raises an error if @non_assigned_required array is not empty.
-      #
-      def check_requirement!
-        unless @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}'"
+    # 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
   end
 end

data/lib/thor/parser/option.rb

@@ -1,16 +1,18 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default, :hide
+    attr_reader :aliases, :group, :lazy_default, :hide, :repeatable
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
-    def initialize(name, options={})
+    def initialize(name, options = {})
+      @check_default_type = options[:check_default_type]
       options[:required] = false unless options.key?(:required)
+      @repeatable     = options.fetch(:repeatable, false)
       super
-      @lazy_default = options[:lazy_default]
-      @group        = options[:group].to_s.capitalize if options[:group]
-      @aliases      = Array(options[:aliases])
-      @hide         = options[:hide]
+      @lazy_default   = options[:lazy_default]
+      @group          = options[:group].to_s.capitalize if options[:group]
+      @aliases        = Array(options[:aliases])
+      @hide           = options[:hide]
     end
 
     # This parse quick options given as method_options. It makes several
@@ -44,7 +46,8 @@ class Thor
       if key.is_a?(Array)
         name, *aliases = key
       else
-        name, aliases = key, []
+        name = key
+        aliases = []
       end
 
       name    = name.to_s
@@ -55,7 +58,7 @@ class Thor
         default = nil
         if VALID_TYPES.include?(value)
           value
-        elsif required = (value == :required)
+        elsif required = (value == :required) # rubocop:disable AssignmentInCondition
           :string
         end
       when TrueClass, FalseClass
@@ -65,7 +68,8 @@ class Thor
       when Hash, Array, String
         value.class.name.downcase.to_sym
       end
-      self.new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
+
+      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
     end
 
     def switch_name
@@ -76,14 +80,18 @@ class Thor
       @human_name ||= dasherized? ? undasherize(name) : name
     end
 
-    def usage(padding=0)
+    def usage(padding = 0)
       sample = if banner && !banner.to_s.empty?
-        "#{switch_name}=#{banner}"
+        "#{switch_name}=#{banner}".dup
       else
         switch_name
       end
 
-      sample = "[#{sample}]" unless required?
+      sample = "[#{sample}]".dup unless required?
+
+      if boolean?
+        sample << ", [#{dasherize('no-' + human_name)}]" unless (name == "force") || name.start_with?("no-")
+      end
 
       if aliases.empty?
         (" " * padding) << sample
@@ -104,18 +112,48 @@ class Thor
 
     def validate!
       raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+      validate_default_type!
+    end
+
+    def validate_default_type!
+      default_type = case @default
+      when nil
+        return
+      when TrueClass, FalseClass
+        required? ? :string : :boolean
+      when Numeric
+        :numeric
+      when Symbol
+        :string
+      when Hash, Array, String
+        @default.class.name.downcase.to_sym
+      end
+
+      expected_type = (@repeatable && @type != :hash) ? :array : @type
+
+      if default_type != expected_type
+        err = "Expected #{expected_type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})"
+
+        if @check_default_type
+          raise ArgumentError, err
+        elsif @check_default_type == nil
+          Thor.deprecation_warning "#{err}.\n" +
+            'This will be rejected in the future unless you explicitly pass the options `check_default_type: false`' +
+            ' or call `allow_incompatible_default_type!` in your code'
+        end
+      end
     end
 
     def dasherized?
-      name.index('-') == 0
+      name.index("-") == 0
     end
 
     def undasherize(str)
-      str.sub(/^-{1,2}/, '')
+      str.sub(/^-{1,2}/, "")
     end
 
     def dasherize(str)
-      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+      (str.length > 1 ? "--" : "-") + str.tr("_", "-")
     end
   end
 end