thor 0.14.6 → 0.19.4

data/lib/thor/parser/argument.rb

@@ -1,22 +1,25 @@
 class Thor
   class Argument #:nodoc:
-    VALID_TYPES = [ :numeric, :hash, :array, :string ]
+    VALID_TYPES = [:numeric, :hash, :array, :string]
 
-    attr_reader :name, :description, :required, :type, :default, :banner
-    alias :human_name :name
+    attr_reader :name, :description, :enum, :required, :type, :default, :banner
+    alias_method :human_name, :name
 
-    def initialize(name, description=nil, required=true, type=:string, default=nil, banner=nil)
+    def initialize(name, options = {})
       class_name = self.class.name.split("::").last
 
+      type = options[:type]
+
       raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
       raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
 
       @name        = name.to_s
-      @description = description
-      @required    = required || false
+      @description = options[:desc]
+      @required    = options.key?(:required) ? options[:required] : true
       @type        = (type || :string).to_sym
-      @default     = default
-      @banner      = banner || default_banner
+      @default     = options[:default]
+      @banner      = options[:banner] || default_banner
+      @enum        = options[:enum]
 
       validate! # Trigger specific validations
     end
@@ -38,30 +41,30 @@ class Thor
       end
     end
 
-    protected
+  protected
 
-      def validate!
-        raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
-      end
+    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)
+    end
 
-      def valid_type?(type)
-        self.class::VALID_TYPES.include?(type.to_sym)
-      end
+    def valid_type?(type)
+      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"
-        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"
       end
-
+    end
   end
 end

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.
@@ -13,7 +13,7 @@ class Thor
         arguments << item
       end
 
-      return arguments, args[Range.new(arguments.size, -1)]
+      [arguments, args[Range.new(arguments.size, -1)]]
     end
 
     def self.parse(*args)
@@ -23,12 +23,13 @@ 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
+        if !argument.default.nil?
           @assigns[argument.human_name] = argument.default
         elsif argument.required?
           @non_assigned_required << argument
@@ -49,113 +50,126 @@ class Thor
       @assigns
     end
 
-    private
+    def remaining
+      @pile
+    end
 
-      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(':')
-          hash[key] = value
-        end
-        hash
-      end
+    def current_is_value?
+      peek && peek.to_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
-          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}"
         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,14 +1,16 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default
+    attr_reader :aliases, :group, :lazy_default, :hide
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
-    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)
-      @lazy_default = lazy_default
-      @group        = group.to_s.capitalize if group
-      @aliases      = [*aliases].compact
+    def initialize(name, options = {})
+      options[:required] = false unless options.key?(:required)
+      super
+      @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
@@ -42,7 +44,8 @@ class Thor
       if key.is_a?(Array)
         name, *aliases = key
       else
-        name, aliases = key, []
+        name = key
+        aliases = []
       end
 
       name    = name.to_s
@@ -53,7 +56,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
@@ -64,7 +67,7 @@ class Thor
         value.class.name.downcase.to_sym
       end
 
-      self.new(name.to_s, nil, required, type, default, nil, nil, nil, aliases)
+      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
     end
 
     def switch_name
@@ -75,7 +78,7 @@ 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}"
       else
@@ -84,6 +87,10 @@ class Thor
 
       sample = "[#{sample}]" unless required?
 
+      if boolean?
+        sample << ", [#{dasherize('no-' + human_name)}]" unless (name == "force") || name.start_with?("no-")
+      end
+
       if aliases.empty?
         (" " * padding) << sample
       else
@@ -103,18 +110,37 @@ 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
+
+      # TODO: This should raise an ArgumentError in a future version of Thor
+      warn "Expected #{@type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})" unless default_type == @type
     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