bundler 2.0.2 → 2.1.0

data/lib/bundler/vendor/thor/lib/thor/base.rb

@@ -1,17 +1,17 @@
-require "bundler/vendor/thor/lib/thor/command"
-require "bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access"
-require "bundler/vendor/thor/lib/thor/core_ext/ordered_hash"
-require "bundler/vendor/thor/lib/thor/error"
-require "bundler/vendor/thor/lib/thor/invocation"
-require "bundler/vendor/thor/lib/thor/parser"
-require "bundler/vendor/thor/lib/thor/shell"
-require "bundler/vendor/thor/lib/thor/line_editor"
-require "bundler/vendor/thor/lib/thor/util"
+require_relative "command"
+require_relative "core_ext/hash_with_indifferent_access"
+require_relative "error"
+require_relative "invocation"
+require_relative "nested_context"
+require_relative "parser"
+require_relative "shell"
+require_relative "line_editor"
+require_relative "util"
 
 class Bundler::Thor
-  autoload :Actions,    "bundler/vendor/thor/lib/thor/actions"
-  autoload :RakeCompat, "bundler/vendor/thor/lib/thor/rake_compat"
-  autoload :Group,      "bundler/vendor/thor/lib/thor/group"
+  autoload :Actions,    File.expand_path("actions", __dir__)
+  autoload :RakeCompat, File.expand_path("rake_compat", __dir__)
+  autoload :Group,      File.expand_path("group", __dir__)
 
   # Shortcuts for help.
   HELP_MAPPINGS       = %w(-h -? --help -D)
@@ -89,6 +89,7 @@ class Bundler::Thor
 
     class << self
       def included(base) #:nodoc:
+        super(base)
         base.extend ClassMethods
         base.send :include, Invocation
         base.send :include, Shell
@@ -113,7 +114,7 @@ class Bundler::Thor
       end
 
       # Whenever a class inherits from Bundler::Thor or Bundler::Thor::Group, we should track the
-      # class and the file on Bundler::Thor::Base. This is the method responsable for it.
+      # class and the file on Bundler::Thor::Base. This is the method responsible for it.
       #
       def register_klass_file(klass) #:nodoc:
         file = caller[1].match(/(.*):\d+/)[1]
@@ -153,17 +154,20 @@ class Bundler::Thor
 
       # If you want to raise an error when the default value of an option does not match
       # the type call check_default_type!
-      # This is disabled by default for compatibility.
+      # This will be the default; for compatibility a deprecation warning is issued if necessary.
       def check_default_type!
         @check_default_type = true
       end
 
-      def check_default_type #:nodoc:
-        @check_default_type ||= from_superclass(:check_default_type, false)
+      # If you want to use defaults that don't match the type of an option,
+      # either specify `check_default_type: false` or call `allow_incompatible_default_type!`
+      def allow_incompatible_default_type!
+        @check_default_type = false
       end
 
-      def check_default_type? #:nodoc:
-        !!check_default_type
+      def check_default_type #:nodoc:
+        @check_default_type = from_superclass(:check_default_type, nil) unless defined?(@check_default_type)
+        @check_default_type
       end
 
       # If true, option parsing is suspended as soon as an unknown option or a
@@ -353,22 +357,22 @@ class Bundler::Thor
       # Returns the commands for this Bundler::Thor class.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Bundler::Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Bundler::Thor::Command
+      #        objects as values.
       #
       def commands
-        @commands ||= Bundler::Thor::CoreExt::OrderedHash.new
+        @commands ||= Hash.new
       end
       alias_method :tasks, :commands
 
       # Returns the commands for this Bundler::Thor class and all subclasses.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Bundler::Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Bundler::Thor::Command
+      #        objects as values.
       #
       def all_commands
-        @all_commands ||= from_superclass(:all_commands, Bundler::Thor::CoreExt::OrderedHash.new)
+        @all_commands ||= from_superclass(:all_commands, Hash.new)
         @all_commands.merge!(commands)
       end
       alias_method :all_tasks, :all_commands
@@ -415,14 +419,20 @@ class Bundler::Thor
       #     remove_command :this_is_not_a_command
       #   end
       #
-      def no_commands
-        @no_commands = true
-        yield
-      ensure
-        @no_commands = false
+      def no_commands(&block)
+        no_commands_context.enter(&block)
       end
+
       alias_method :no_tasks, :no_commands
 
+      def no_commands_context
+        @no_commands_context ||= NestedContext.new
+      end
+
+      def no_commands?
+        no_commands_context.entered?
+      end
+
       # Sets the namespace for the Bundler::Thor or Bundler::Thor::Group class. By default the
       # namespace is retrieved from the class name. If your Bundler::Thor class is named
       # Scripts::MyScript, the help method, for example, will be called as:
@@ -502,10 +512,16 @@ class Bundler::Thor
         msg = "ERROR: \"#{basename} #{name}\" was called with ".dup
         msg << "no arguments"               if     args.empty?
         msg << "arguments " << args.inspect unless args.empty?
-        msg << "\nUsage: #{banner(command).inspect}"
+        msg << "\nUsage: \"#{banner(command).split("\n").join("\"\n       \"")}\""
         raise InvocationError, msg
       end
 
+      # A flag that makes the process exit with status 1 if any error happens.
+      def exit_on_failure?
+        Bundler::Thor.deprecation_warning "Bundler::Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `#{self.name}`"
+        false
+      end
+
     protected
 
       # Prints the class options per group. If an option does not belong to
@@ -563,7 +579,7 @@ class Bundler::Thor
       # options<Hash>:: Described in both class_option and method_option.
       # scope<Hash>:: Options hash that is being built up
       def build_option(name, options, scope) #:nodoc:
-        scope[name] = Bundler::Thor::Option.new(name, options.merge(:check_default_type => check_default_type?))
+        scope[name] = Bundler::Thor::Option.new(name, {:check_default_type => check_default_type}.merge!(options))
       end
 
       # Receives a hash of options, parse them and add to the scope. This is a
@@ -596,13 +612,15 @@ class Bundler::Thor
       # Everytime someone inherits from a Bundler::Thor class, register the klass
       # and file into baseclass.
       def inherited(klass)
+        super(klass)
         Bundler::Thor::Base.register_klass_file(klass)
-        klass.instance_variable_set(:@no_commands, false)
+        klass.instance_variable_set(:@no_commands, 0)
       end
 
       # Fire this callback whenever a method is added. Added methods are
       # tracked as commands by invoking the create_command method.
       def method_added(meth)
+        super(meth)
         meth = meth.to_s
 
         if meth == "initialize"
@@ -613,8 +631,7 @@ class Bundler::Thor
         # Return if it's not a public instance method
         return unless public_method_defined?(meth.to_sym)
 
-        @no_commands ||= false
-        return if @no_commands || !create_command(meth)
+        return if no_commands? || !create_command(meth)
 
         is_thor_reserved_word?(meth, :command)
         Bundler::Thor::Base.register_klass_file(self)
@@ -641,11 +658,6 @@ class Bundler::Thor
         end
       end
 
-      # A flag that makes the process exit with status 1 if any error happens.
-      def exit_on_failure?
-        false
-      end
-
       #
       # The basename of the program invoking the thor class.
       #

data/lib/bundler/vendor/thor/lib/thor/command.rb

@@ -49,24 +49,32 @@ class Bundler::Thor
 
       formatted ||= "".dup
 
-      # Add usage with required arguments
-      formatted << if klass && !klass.arguments.empty?
-                     usage.to_s.gsub(/^#{name}/) do |match|
-                       match << " " << klass.arguments.map(&:usage).compact.join(" ")
-                     end
-                   else
-                     usage.to_s
-                   end
+      Array(usage).map do |specific_usage|
+        formatted_specific_usage = formatted
 
-      # Add required options
-      formatted << " #{required_options}"
+        formatted_specific_usage += required_arguments_for(klass, specific_usage)
 
-      # Strip and go!
-      formatted.strip
+        # Add required options
+        formatted_specific_usage += " #{required_options}"
+
+        # Strip and go!
+        formatted_specific_usage.strip
+      end.join("\n")
     end
 
   protected
 
+    # Add usage with required arguments
+    def required_arguments_for(klass, usage)
+      if klass && !klass.arguments.empty?
+        usage.to_s.gsub(/^#{name}/) do |match|
+          match << " " << klass.arguments.map(&:usage).compact.join(" ")
+        end
+      else
+        usage.to_s
+      end
+    end
+
     def not_debugging?(instance)
       !(instance.class.respond_to?(:debugging) && instance.class.debugging)
     end
@@ -97,8 +105,7 @@ class Bundler::Thor
     def handle_argument_error?(instance, error, caller)
       not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && begin
         saned = sans_backtrace(error.backtrace, caller)
-        # Ruby 1.9 always include the called method in the backtrace
-        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
+        saned.empty? || saned.size == 1
       end
     end
 

data/lib/bundler/vendor/thor/lib/thor/error.rb

@@ -1,22 +1,18 @@
 class Bundler::Thor
-  Correctable =
-    begin
-      require 'did_you_mean'
-
-      # 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
-    rescue LoadError, NameError
-    end
+  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable)
+                  # 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
 
   # Bundler::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.

data/lib/bundler/vendor/thor/lib/thor/group.rb

@@ -1,4 +1,4 @@
-require "bundler/vendor/thor/lib/thor/base"
+require_relative "base"
 
 # Bundler::Thor has a special class called Bundler::Thor::Group. The main difference to Bundler::Thor class
 # is that it invokes all commands at once. It also include some methods that allows

data/lib/bundler/vendor/thor/lib/thor/invocation.rb

@@ -1,6 +1,7 @@
 class Bundler::Thor
   module Invocation
     def self.included(base) #:nodoc:
+      super(base)
       base.extend ClassMethods
     end
 

data/lib/bundler/vendor/thor/lib/thor/line_editor.rb

@@ -1,5 +1,5 @@
-require "bundler/vendor/thor/lib/thor/line_editor/basic"
-require "bundler/vendor/thor/lib/thor/line_editor/readline"
+require_relative "line_editor/basic"
+require_relative "line_editor/readline"
 
 class Bundler::Thor
   module LineEditor

data/lib/bundler/vendor/thor/lib/thor/line_editor/basic.rb

@@ -24,7 +24,7 @@ class Bundler::Thor
           $stdin.gets
         else
           # Lazy-load io/console since it is gem-ified as of 2.3
-          require "io/console" if RUBY_VERSION > "1.9.2"
+          require "io/console"
           $stdin.noecho(&:gets)
         end
       end

data/lib/bundler/vendor/thor/lib/thor/line_editor/readline.rb

@@ -1,19 +1,19 @@
-begin
-  require "readline"
-rescue LoadError
-end
-
 class Bundler::Thor
   module LineEditor
     class Readline < Basic
       def self.available?
+        begin
+          require "readline"
+        rescue LoadError
+        end
+
         Object.const_defined?(:Readline)
       end
 
       def readline
         if echo?
           ::Readline.completion_append_character = nil
-          # Ruby 1.8.7 does not allow Readline.completion_proc= to receive nil.
+          # rb-readline does not allow Readline.completion_proc= to receive nil.
           if complete = completion_proc
             ::Readline.completion_proc = complete
           end

data/lib/bundler/vendor/thor/lib/thor/nested_context.rb

@@ -0,0 +1,29 @@
+class Bundler::Thor
+  class NestedContext
+    def initialize
+      @depth = 0
+    end
+
+    def enter
+      push
+
+      yield
+    ensure
+      pop
+    end
+
+    def entered?
+      @depth > 0
+    end
+
+    private
+
+    def push
+      @depth += 1
+    end
+
+    def pop
+      @depth -= 1
+    end
+  end
+end

data/lib/bundler/vendor/thor/lib/thor/parser.rb

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

data/lib/bundler/vendor/thor/lib/thor/parser/arguments.rb

@@ -9,7 +9,7 @@ class Bundler::Thor
       arguments = []
 
       args.each do |item|
-        break if item =~ /^-/
+        break if item.is_a?(String) && item =~ /^-/
         arguments << item
       end
 
@@ -82,7 +82,7 @@ class Bundler::Thor
     end
 
     def current_is_value?
-      peek && peek.to_s !~ /^-/
+      peek && peek.to_s !~ /^-{1,2}\S+/
     end
 
     # Runs through the argument array getting strings that contains ":" and

data/lib/bundler/vendor/thor/lib/thor/parser/option.rb

@@ -1,17 +1,18 @@
 class Bundler::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 = {})
       @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
@@ -111,7 +112,7 @@ class Bundler::Thor
 
     def validate!
       raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
-      validate_default_type! if @check_default_type
+      validate_default_type!
     end
 
     def validate_default_type!
@@ -128,7 +129,19 @@ class Bundler::Thor
         @default.class.name.downcase.to_sym
       end
 
-      raise ArgumentError, "Expected #{@type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})" unless default_type == @type
+      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
+          Bundler::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?