thor 1.1.0 → 1.4.0

data/lib/thor/command.rb

@@ -1,14 +1,15 @@
 class Thor
-  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
+  class Command < Struct.new(:name, :description, :long_description, :wrap_long_description, :usage, :options, :options_relation, :ancestor_name)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
-    def initialize(name, description, long_description, usage, options = nil)
-      super(name.to_s, description, long_description, usage, options || {})
+    def initialize(name, description, long_description, wrap_long_description, usage, options = nil, options_relation = nil)
+      super(name.to_s, description, long_description, wrap_long_description, usage, options || {}, options_relation || {})
     end
 
     def initialize_copy(other) #:nodoc:
       super(other)
       self.options = other.options.dup if other.options
+      self.options_relation = other.options_relation.dup if other.options_relation
     end
 
     def hidden?
@@ -62,6 +63,14 @@ class Thor
       end.join("\n")
     end
 
+    def method_exclusive_option_names #:nodoc:
+      self.options_relation[:exclusive_option_names] || []
+    end
+
+    def method_at_least_one_option_names #:nodoc:
+      self.options_relation[:at_least_one_option_names] || []
+    end
+
   protected
 
     # Add usage with required arguments
@@ -127,7 +136,7 @@ class Thor
   # A dynamic command that handles method missing scenarios.
   class DynamicCommand < Command
     def initialize(name, options = nil)
-      super(name.to_s, "A dynamically-generated command", name.to_s, name.to_s, options)
+      super(name.to_s, "A dynamically-generated command", name.to_s, nil, name.to_s, options)
     end
 
     def run(instance, args = [])

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -28,10 +28,20 @@ class Thor
         super(convert_key(key))
       end
 
+      def except(*keys)
+        dup.tap do |hash|
+          keys.each { |key| hash.delete(convert_key(key)) }
+        end
+      end
+
       def fetch(key, *args)
         super(convert_key(key), *args)
       end
 
+      def slice(*keys)
+        super(*keys.map{ |key| convert_key(key) })
+      end
+
       def key?(key)
         super(convert_key(key))
       end

data/lib/thor/error.rb

@@ -1,18 +1,15 @@
 class Thor
   Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable) # rubocop:disable Naming/ConstantName
-                  # In order to support versions of Ruby that don't have keyword
-                  # arguments, we need our own spell checker class that doesn't take key
-                  # words. Even though this code wouldn't be hit because of the check
-                  # above, it's still necessary because the interpreter would otherwise be
-                  # unable to parse the file.
-                  class NoKwargSpellChecker < DidYouMean::SpellChecker # :nodoc:
-                    def initialize(dictionary)
-                      @dictionary = dictionary
-                    end
-                  end
-
-                  DidYouMean::Correctable
-                end
+    Module.new do
+      def to_s
+        super + DidYouMean.formatter.message_for(corrections)
+      end
+
+      def corrections
+        @corrections ||= self.class.const_get(:SpellChecker).new(self).corrections
+      end
+    end
+  end
 
   # Thor::Error is raised when it's caused by wrong usage of thor classes. Those
   # errors have their backtrace suppressed and are nicely shown to the user.
@@ -37,7 +34,7 @@ class Thor
       end
 
       def spell_checker
-        NoKwargSpellChecker.new(error.all_commands)
+        DidYouMean::SpellChecker.new(dictionary: error.all_commands)
       end
     end
 
@@ -79,7 +76,7 @@ class Thor
       end
 
       def spell_checker
-        @spell_checker ||= NoKwargSpellChecker.new(error.switches)
+        @spell_checker ||= DidYouMean::SpellChecker.new(dictionary: error.switches)
       end
     end
 
@@ -101,10 +98,9 @@ class Thor
   class MalformattedArgumentError < InvocationError
   end
 
-  if Correctable
-    DidYouMean::SPELL_CHECKERS.merge!(
-      'Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
-      'Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
-    )
+  class ExclusiveArgumentError < InvocationError
+  end
+
+  class AtLeastOneRequiredArgumentError < InvocationError
   end
 end

data/lib/thor/group.rb

@@ -169,7 +169,7 @@ class Thor::Group
     # options are added to group_options hash. Options that already exists
     # in base_options are not added twice.
     #
-    def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
+    def get_options_from_invocations(group_options, base_options) #:nodoc:
       invocations.each do |name, from_option|
         value = if from_option
           option = class_options[name]
@@ -211,6 +211,17 @@ class Thor::Group
       raise error, msg
     end
 
+    # Checks if a specified command exists.
+    #
+    # ==== Parameters
+    # command_name<String>:: The name of the command to check for existence.
+    #
+    # ==== Returns
+    # Boolean:: +true+ if the command exists, +false+ otherwise.
+    def command_exists?(command_name) #:nodoc:
+      commands.keys.include?(command_name)
+    end
+
   protected
 
     # The method responsible for dispatching given the args.

data/lib/thor/invocation.rb

@@ -143,7 +143,7 @@ class Thor
 
     # Configuration values that are shared between invocations.
     def _shared_configuration #:nodoc:
-      {:invocations => @_invocations}
+      {invocations: @_invocations}
     end
 
     # This method simply retrieves the class and command to be invoked.

data/lib/thor/nested_context.rb

@@ -13,10 +13,10 @@ class Thor
     end
 
     def entered?
-      @depth > 0
+      @depth.positive?
     end
 
-    private
+  private
 
     def push
       @depth += 1

data/lib/thor/parser/argument.rb

@@ -24,6 +24,14 @@ class Thor
       validate! # Trigger specific validations
     end
 
+    def print_default
+      if @type == :array and @default.is_a?(Array)
+        @default.map(&:dump).join(" ")
+      else
+        @default
+      end
+    end
+
     def usage
       required? ? banner : "[#{banner}]"
     end
@@ -41,11 +49,19 @@ class Thor
       end
     end
 
+    def enum_to_s
+      if enum.respond_to? :join
+        enum.join(", ")
+      else
+        "#{enum.first}..#{enum.last}"
+      end
+    end
+
   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)
+      raise ArgumentError, "An argument cannot have an enum other than an enumerable." if @enum && !@enum.is_a?(Enumerable)
     end
 
     def valid_type?(type)

data/lib/thor/parser/arguments.rb

@@ -1,5 +1,5 @@
 class Thor
-  class Arguments #:nodoc: # rubocop:disable ClassLength
+  class Arguments #:nodoc:
     NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
@@ -30,11 +30,7 @@ class Thor
 
       arguments.each do |argument|
         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
+          @assigns[argument.human_name] = argument.default.dup
         elsif argument.required?
           @non_assigned_required << argument
         end
@@ -121,8 +117,18 @@ class Thor
     #
     def parse_array(name)
       return shift if peek.is_a?(Array)
+
       array = []
-      array << shift while current_is_value?
+
+      while current_is_value?
+        value = shift
+
+        if !value.empty?
+          validate_enum_value!(name, value, "Expected all values of '%s' to be one of %s; got %s")
+        end
+
+        array << value
+      end
       array
     end
 
@@ -138,11 +144,9 @@ class Thor
       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}"
-        end
-      end
+
+      validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
+
       value
     end
 
@@ -156,15 +160,27 @@ class Thor
         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
+
+        validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
+
         value
       end
     end
 
+    # Raises an error if the switch is an enum and the values aren't included on it.
+    #
+    def validate_enum_value!(name, value, message)
+      return unless @switches.is_a?(Hash)
+
+      switch = @switches[name]
+
+      return unless switch
+
+      if switch.enum && !switch.enum.include?(value)
+        raise MalformattedArgumentError, message % [name, switch.enum_to_s, value]
+      end
+    end
+
     # Raises an error if @non_assigned_required array is not empty.
     #
     def check_requirement!

data/lib/thor/parser/option.rb

@@ -11,7 +11,7 @@ class Thor
       super
       @lazy_default   = options[:lazy_default]
       @group          = options[:group].to_s.capitalize if options[:group]
-      @aliases        = Array(options[:aliases])
+      @aliases        = normalize_aliases(options[:aliases])
       @hide           = options[:hide]
     end
 
@@ -58,7 +58,7 @@ class Thor
         default = nil
         if VALID_TYPES.include?(value)
           value
-        elsif required = (value == :required) # rubocop:disable AssignmentInCondition
+        elsif required = (value == :required) # rubocop:disable Lint/AssignmentInCondition
           :string
         end
       when TrueClass, FalseClass
@@ -69,7 +69,7 @@ class Thor
         value.class.name.downcase.to_sym
       end
 
-      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
@@ -89,14 +89,27 @@ class Thor
 
       sample = "[#{sample}]".dup unless required?
 
-      if boolean?
-        sample << ", [#{dasherize('no-' + human_name)}]" unless (name == "force") || name.start_with?("no-")
+      if boolean? && name != "force" && !name.match(/\A(no|skip)[\-_]/)
+        sample << ", [#{dasherize('no-' + human_name)}], [#{dasherize('skip-' + human_name)}]"
       end
 
+      aliases_for_usage.ljust(padding) + sample
+    end
+
+    def aliases_for_usage
       if aliases.empty?
-        (" " * padding) << sample
+        ""
+      else
+        "#{aliases.join(', ')}, "
+      end
+    end
+
+    def show_default?
+      case default
+      when TrueClass, FalseClass
+        true
       else
-        "#{aliases.join(', ')}, #{sample}"
+        super
       end
     end
 
@@ -138,8 +151,8 @@ class Thor
           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'
+            "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
@@ -155,5 +168,11 @@ class Thor
     def dasherize(str)
       (str.length > 1 ? "--" : "-") + str.tr("_", "-")
     end
+
+  private
+
+    def normalize_aliases(aliases)
+      Array(aliases).map { |short| short.to_s.sub(/^(?!\-)/, "-") }
+    end
   end
 end

data/lib/thor/parser/options.rb

@@ -1,5 +1,5 @@
 class Thor
-  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
+  class Options < Arguments #:nodoc:
     LONG_RE     = /^(--\w+(?:-\w+)*)$/
     SHORT_RE    = /^(-[a-z])$/i
     EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
@@ -29,8 +29,10 @@ class Thor
     #
     # 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)
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false, relations = {})
       @stop_on_unknown = stop_on_unknown
+      @exclusives = (relations[:exclusive_option_names] || []).select{|array| !array.empty?}
+      @at_least_ones = (relations[:at_least_one_option_names] || []).select{|array| !array.empty?}
       @disable_required_check = disable_required_check
       options = hash_options.values
       super(options)
@@ -45,12 +47,12 @@ class Thor
       @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|
-          name = short.to_s.sub(/^(?!\-)/, "-")
+        option.aliases.each do |name|
           @shorts[name] ||= option.switch_name
         end
       end
@@ -74,8 +76,19 @@ class Thor
       end
     end
 
-    def parse(args) # rubocop:disable MethodLength
+    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 Metrics/MethodLength
       @pile = args.dup
+      @is_treated_as_value = false
       @parsing_options = true
 
       while peek
@@ -88,7 +101,10 @@ class Thor
             when SHORT_SQ_RE
               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
@@ -117,12 +133,38 @@ class Thor
       end
 
       check_requirement! unless @disable_required_check
+      check_exclusive!
+      check_at_least_one!
 
       assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
       assigns.freeze
       assigns
     end
 
+    def check_exclusive!
+      opts = @assigns.keys
+      # When option A and B are exclusive, if A and B are given at the same time,
+      # the difference of argument array size will decrease.
+      found = @exclusives.find{ |ex| (ex - opts).size < ex.size - 1 }
+      if found
+        names = names_to_switch_names(found & opts).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail ExclusiveArgumentError, "Found exclusive #{class_name} #{names.join(", ")}"
+      end
+    end
+
+    def check_at_least_one!
+      opts = @assigns.keys
+      # When at least one is required of the options A and B,
+      # if the both options were not given, none? would be true.
+      found = @at_least_ones.find{ |one_reqs| one_reqs.none?{ |o| opts.include? o} }
+      if found
+        names = names_to_switch_names(found).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail AtLeastOneRequiredArgumentError, "Not found at least one of required #{class_name} #{names.join(", ")}"
+      end
+    end
+
     def check_unknown!
       to_check = @stopped_parsing_after_extra_index ? @extra[0...@stopped_parsing_after_extra_index] : @extra
 
@@ -133,6 +175,17 @@ class Thor
 
   protected
 
+    # Option names changes to swith name or human name
+    def names_to_switch_names(names = [])
+      @switches.map do |_, o|
+        if names.include? o.name
+          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+        else
+          nil
+        end
+      end.compact
+    end
+
     def assign_result!(option, result)
       if option.repeatable && option.type == :hash
         (@assigns[option.human_name] ||= {}).merge!(result)
@@ -148,6 +201,7 @@ class Thor
     # 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)]
@@ -159,6 +213,7 @@ class Thor
     end
 
     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
@@ -168,6 +223,7 @@ class Thor
     end
 
     def current_is_value?
+      return true if @is_treated_as_value
       peek && (!parsing_options? || super)
     end
 
@@ -176,7 +232,7 @@ class Thor
     end
 
     def switch_option(arg)
-      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
+      if match = no_or_skip?(arg) # rubocop:disable Lint/AssignmentInCondition
         @switches[arg] || @switches["--#{match}"]
       else
         @switches[arg]
@@ -194,7 +250,8 @@ class Thor
       @parsing_options
     end
 
-    # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+    # Parse boolean values which can be given as --foo=true or --foo for true values, or
+    # --foo=false, --no-foo or --skip-foo for false values.
     #
     def parse_boolean(switch)
       if current_is_value?

data/lib/thor/rake_compat.rb

@@ -41,7 +41,7 @@ instance_eval do
   def task(*)
     task = super
 
-    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
       non_namespaced_name = task.name.split(":").last
 
       description = non_namespaced_name
@@ -59,7 +59,7 @@ instance_eval do
   end
 
   def namespace(name)
-    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/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)