bundler 1.9.0 → 1.17.3

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/command.rb

@@ -1,5 +1,5 @@
 class Bundler::Thor
-  class Command < Struct.new(:name, :description, :long_description, :usage, :options)
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
     def initialize(name, description, long_description, usage, options = nil)
@@ -33,24 +33,26 @@ class Bundler::Thor
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
     rescue NoMethodError => e
-      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (fail e)
+      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
     end
 
     # Returns the formatted usage by injecting given required arguments
     # and required options into the given usage.
     def formatted_usage(klass, namespace = true, subcommand = false)
-      if namespace
+      if ancestor_name
+        formatted = "#{ancestor_name} ".dup # add space
+      elsif namespace
         namespace = klass.namespace
-        formatted = "#{namespace.gsub(/^(default)/, '')}:"
+        formatted = "#{namespace.gsub(/^(default)/, '')}:".dup
       end
-      formatted = "#{klass.namespace.split(':').last} " if subcommand
+      formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand
 
-      formatted ||= ""
+      formatted ||= "".dup
 
       # Add usage with required arguments
       formatted << if klass && !klass.arguments.empty?
                      usage.to_s.gsub(/^#{name}/) do |match|
-                       match << " " << klass.arguments.map { |a| a.usage }.compact.join(" ")
+                       match << " " << klass.arguments.map(&:usage).compact.join(" ")
                      end
                    else
                      usage.to_s
@@ -88,7 +90,7 @@ class Bundler::Thor
     end
 
     def sans_backtrace(backtrace, caller) #:nodoc:
-      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ /^kernel\// && RUBY_ENGINE =~ /rbx/) }
+      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) }
       saned - caller
     end
 
@@ -105,7 +107,7 @@ class Bundler::Thor
         error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
     end
   end
-  Task = Command # rubocop:disable ConstantName
+  Task = Command
 
   # A command that is hidden in help messages but still invocable.
   class HiddenCommand < Command
@@ -113,7 +115,7 @@ class Bundler::Thor
       true
     end
   end
-  HiddenTask = HiddenCommand # rubocop:disable ConstantName
+  HiddenTask = HiddenCommand
 
   # A dynamic command that handles method missing scenarios.
   class DynamicCommand < Command
@@ -129,5 +131,5 @@ class Bundler::Thor
       end
     end
   end
-  DynamicTask = DynamicCommand # rubocop:disable ConstantName
+  DynamicTask = DynamicCommand
 end

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -28,6 +28,14 @@ class Bundler::Thor
         super(convert_key(key))
       end
 
+      def fetch(key, *args)
+        super(convert_key(key), *args)
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
       def values_at(*indices)
         indices.map { |key| self[convert_key(key)] }
       end
@@ -43,6 +51,18 @@ class Bundler::Thor
         self
       end
 
+      def reverse_merge(other)
+        self.class.new(other).merge(self)
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge(other_hash))
+      end
+
+      def replace(other_hash)
+        super(other_hash)
+      end
+
       # Convert to a Hash with String keys.
       def to_hash
         Hash.new(default).merge!(self)
@@ -60,7 +80,7 @@ class Bundler::Thor
       #   options.shebang                 # => "/usr/lib/local/ruby"
       #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
       #
-      def method_missing(method, *args, &block)
+      def method_missing(method, *args)
         method = method.to_s
         if method =~ /^(\w+)\?$/
           if args.empty?

data/lib/bundler/vendor/thor/lib/thor/core_ext/io_binary_read.rb

@@ -0,0 +1,12 @@
+class IO #:nodoc:
+  class << self
+    unless method_defined? :binread
+      def binread(file, *args)
+        raise ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
+        File.open(file, "rb") do |f|
+          f.read(*args)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendor/thor/lib/thor/core_ext/ordered_hash.rb

@@ -0,0 +1,129 @@
+class Bundler::Thor
+  module CoreExt
+    class OrderedHash < ::Hash
+      if RUBY_VERSION < "1.9"
+        def initialize(*args, &block)
+          super
+          @keys = []
+        end
+
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
+        end
+
+        def []=(key, value)
+          @keys << key unless key?(key)
+          super
+        end
+
+        def delete(key)
+          if key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
+
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
+
+        alias_method :reject!, :delete_if
+
+        def reject(&block)
+          dup.reject!(&block)
+        end
+
+        def keys
+          @keys.dup
+        end
+
+        def values
+          @keys.map { |key| self[key] }
+        end
+
+        def to_hash
+          self
+        end
+
+        def to_a
+          @keys.map { |key| [key, self[key]] }
+        end
+
+        def each_key
+          return to_enum(:each_key) unless block_given?
+          @keys.each { |key| yield(key) }
+          self
+        end
+
+        def each_value
+          return to_enum(:each_value) unless block_given?
+          @keys.each { |key| yield(self[key]) }
+          self
+        end
+
+        def each
+          return to_enum(:each) unless block_given?
+          @keys.each { |key| yield([key, self[key]]) }
+          self
+        end
+
+        def each_pair
+          return to_enum(:each_pair) unless block_given?
+          @keys.each { |key| yield(key, self[key]) }
+          self
+        end
+
+        alias_method :select, :find_all
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
+
+        def merge!(other_hash)
+          if block_given?
+            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+          else
+            other_hash.each { |k, v| self[k] = v }
+          end
+          self
+        end
+
+        alias_method :update, :merge!
+
+        def merge(other_hash, &block)
+          dup.merge!(other_hash, &block)
+        end
+
+        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+        def replace(other)
+          super
+          @keys = other.keys
+          self
+        end
+
+        def inspect
+          "#<#{self.class} #{super}>"
+        end
+
+        private
+
+        def sync_keys!
+          @keys.delete_if { |k| !key?(k) }
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/error.rb

@@ -3,7 +3,7 @@ class Bundler::Thor
   # errors have their backtrace suppressed and are nicely shown to the user.
   #
   # Errors that are caused by the developer, like declaring a method which
-  # overwrites a thor keyword, it SHOULD NOT raise a Bundler::Thor::Error. This way, we
+  # overwrites a thor keyword, SHOULD NOT raise a Bundler::Thor::Error. This way, we
   # ensure that developer errors are shown with full backtrace.
   class Error < StandardError
   end
@@ -11,11 +11,11 @@ class Bundler::Thor
   # Raised when a command was not found.
   class UndefinedCommandError < Error
   end
-  UndefinedTaskError = UndefinedCommandError # rubocop:disable ConstantName
+  UndefinedTaskError = UndefinedCommandError
 
   class AmbiguousCommandError < Error
   end
-  AmbiguousTaskError = AmbiguousCommandError # rubocop:disable ConstantName
+  AmbiguousTaskError = AmbiguousCommandError
 
   # Raised when a command was found, but not invoked properly.
   class InvocationError < Error

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/group.rb

@@ -1,10 +1,10 @@
-require "thor/base"
+require "bundler/vendor/thor/lib/thor/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
 # invocations to be done at the class method, which are not available to Bundler::Thor
 # commands.
-class Bundler::Thor::Group # rubocop:disable ClassLength
+class Bundler::Thor::Group
   class << self
     # The description for this Bundler::Thor::Group. If none is provided, but a source root
     # exists, tries to find the USAGE one folder above it, otherwise searches
@@ -53,7 +53,7 @@ class Bundler::Thor::Group # rubocop:disable ClassLength
     # The namespace/class given will have its options showed on the help
     # usage. Check invoke_from_option for more information.
     #
-    def invoke(*names, &block) # rubocop:disable MethodLength
+    def invoke(*names, &block)
       options = names.last.is_a?(Hash) ? names.pop : {}
       verbose = options.fetch(:verbose, true)
 
@@ -62,7 +62,7 @@ class Bundler::Thor::Group # rubocop:disable ClassLength
         invocation_blocks[name] = block if block_given?
 
         class_eval <<-METHOD, __FILE__, __LINE__
-          def _invoke_#{name.to_s.gsub(/\W/, "_")}
+          def _invoke_#{name.to_s.gsub(/\W/, '_')}
             klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
 
             if klass
@@ -107,21 +107,21 @@ class Bundler::Thor::Group # rubocop:disable ClassLength
     # invoked. The block receives two parameters, an instance of the current
     # class and the klass to be invoked.
     #
-    def invoke_from_option(*names, &block) # rubocop:disable MethodLength
+    def invoke_from_option(*names, &block)
       options = names.last.is_a?(Hash) ? names.pop : {}
       verbose = options.fetch(:verbose, :white)
 
       names.each do |name|
         unless class_options.key?(name)
-          fail ArgumentError, "You have to define the option #{name.inspect} " <<
-                               "before setting invoke_from_option."
+          raise ArgumentError, "You have to define the option #{name.inspect} " \
+                              "before setting invoke_from_option."
         end
 
         invocations[name] = true
         invocation_blocks[name] = block if block_given?
 
         class_eval <<-METHOD, __FILE__, __LINE__
-          def _invoke_from_option_#{name.to_s.gsub(/\W/, "_")}
+          def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
             return unless options[#{name.inspect}]
 
             value = options[#{name.inspect}]
@@ -188,7 +188,7 @@ class Bundler::Thor::Group # rubocop:disable ClassLength
         group_options[human_name] ||= []
         group_options[human_name] += klass.class_options.values.select do |class_option|
           base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
-          !group_options.values.flatten.any? { |i| i.name == class_option.name }
+            !group_options.values.flatten.any? { |i| i.name == class_option.name }
         end
 
         yield klass if block_given?
@@ -204,11 +204,11 @@ class Bundler::Thor::Group # rubocop:disable ClassLength
     end
     alias_method :printable_tasks, :printable_commands
 
-    def handle_argument_error(command, error, args, arity) #:nodoc:
-      msg = "#{basename} #{command.name} takes #{arity} argument"
+    def handle_argument_error(command, error, _args, arity) #:nodoc:
+      msg = "#{basename} #{command.name} takes #{arity} argument".dup
       msg << "s" if arity > 1
       msg << ", but it should not."
-      fail error, msg
+      raise error, msg
     end
 
   protected
@@ -267,9 +267,9 @@ protected
       if block
         case block.arity
         when 3
-          block.call(self, klass, command)
+          yield(self, klass, command)
         when 2
-          block.call(self, klass)
+          yield(self, klass)
         when 1
           instance_exec(klass, &block)
         end

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/invocation.rb

@@ -108,8 +108,8 @@ class Bundler::Thor
       command, args, opts, config = args
 
       klass, command = _retrieve_class_and_command(name, command)
-      fail "Missing Bundler::Thor class for invoke #{name}" unless klass
-      fail "Expected Bundler::Thor class, got #{klass}" unless klass <= Bundler::Thor::Base
+      raise "Missing Bundler::Thor class for invoke #{name}" unless klass
+      raise "Expected Bundler::Thor class, got #{klass}" unless klass <= Bundler::Thor::Base
 
       args, opts, config = _parse_initialization_options(args, opts, config)
       klass.send(:dispatch, command, args, opts, config) do |instance|
@@ -150,10 +150,9 @@ class Bundler::Thor
     # use the given name and return self as class. Otherwise, call
     # prepare_for_invocation in the current class.
     def _retrieve_class_and_command(name, sent_command = nil) #:nodoc:
-      case
-      when name.nil?
+      if name.nil?
         [self.class, nil]
-      when self.class.all_commands[name.to_s]
+      elsif self.class.all_commands[name.to_s]
         [self.class, name.to_s]
       else
         klass, command = self.class.prepare_for_invocation(nil, name)

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/line_editor.rb

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

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/line_editor/basic.rb

@@ -23,6 +23,8 @@ class Bundler::Thor
         if echo?
           $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"
           $stdin.noecho(&:gets)
         end
       end

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

@@ -0,0 +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"

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/parser/argument.rb

@@ -10,8 +10,8 @@ class Bundler::Thor
 
       type = options[:type]
 
-      fail ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
-      fail ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(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 = options[:desc]
@@ -44,11 +44,8 @@ class Bundler::Thor
   protected
 
     def validate!
-      if required? && !default.nil?
-        fail ArgumentError, "An argument cannot be required and have default value."
-      elsif @enum && !@enum.is_a?(Array)
-        fail ArgumentError, "An argument cannot have an enum other than an array."
-      end
+      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)

data/lib/bundler/vendor/{thor-0.19.1 → thor}/lib/thor/parser/arguments.rb

@@ -1,6 +1,6 @@
 class Bundler::Thor
   class Arguments #:nodoc: # rubocop:disable ClassLength
-    NUMERIC = /(\d*\.\d+|\d+)/
+    NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
     # and one with switches.
@@ -24,7 +24,8 @@ class Bundler::Thor
     # Takes an array of Bundler::Thor::Argument objects.
     #
     def initialize(arguments = [])
-      @assigns, @non_assigned_required = {}, []
+      @assigns = {}
+      @non_assigned_required = []
       @switches = arguments
 
       arguments.each do |argument|
@@ -49,7 +50,7 @@ class Bundler::Thor
       @assigns
     end
 
-    def remaining # rubocop:disable TrivialAccessors
+    def remaining
       @pile
     end
 
@@ -73,7 +74,7 @@ class Bundler::Thor
     end
 
     def unshift(arg)
-      if arg.kind_of?(Array)
+      if arg.is_a?(Array)
         @pile = arg + @pile
       else
         @pile.unshift(arg)
@@ -99,6 +100,7 @@ class Bundler::Thor
 
       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
@@ -128,13 +130,13 @@ class Bundler::Thor
       return shift if peek.is_a?(Numeric)
 
       unless peek =~ NUMERIC && $& == peek
-        fail MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
+        raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
       end
 
       value = $&.index(".") ? shift.to_f : shift.to_i
       if @switches.is_a?(Hash) && switch = @switches[name]
         if switch.enum && !switch.enum.include?(value)
-          fail MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+          raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
         end
       end
       value
@@ -150,9 +152,9 @@ class Bundler::Thor
         nil
       else
         value = shift
-        if @switches.is_a?(Hash) && switch = @switches[name] # rubocop:disable AssignmentInCondition
+        if @switches.is_a?(Hash) && switch = @switches[name]
           if switch.enum && !switch.enum.include?(value)
-            fail MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+            raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
           end
         end
         value
@@ -162,14 +164,12 @@ class Bundler::Thor
     # 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
-        fail RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
-      end
+      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