rubygems-update 2.6.14 → 2.7.0

data/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/thor/lib/thor/core_ext/io_binary_read.rb

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

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

@@ -1,96 +1,127 @@
 class Bundler::Thor
-  module CoreExt #:nodoc:
-    if RUBY_VERSION >= "1.9"
-      class OrderedHash < ::Hash
-      end
-    else
-      # This class is based on the Ruby 1.9 ordered hashes.
-      #
-      # It keeps the semantics and most of the efficiency of normal hashes
-      # while also keeping track of the order in which elements were set.
-      #
-      class OrderedHash #:nodoc:
-        include Enumerable
-
-        Node = Struct.new(:key, :value, :next, :prev)
-
-        def initialize
-          @hash = {}
+  module CoreExt
+    class OrderedHash < ::Hash
+      if RUBY_VERSION < "1.9"
+        def initialize(*args, &block)
+          super
+          @keys = []
         end
 
-        def [](key)
-          @hash[key] && @hash[key].value
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
         end
 
         def []=(key, value)
-          if node = @hash[key] # rubocop:disable AssignmentInCondition
-            node.value = value
-          else
-            node = Node.new(key, value)
-
-            if !defined?(@first) || @first.nil?
-              @first = @last = node
-            else
-              node.prev = @last
-              @last.next = node
-              @last = node
-            end
-          end
-
-          @hash[key] = node
-          value
+          @keys << key unless key?(key)
+          super
         end
 
         def delete(key)
-          if node = @hash[key] # rubocop:disable AssignmentInCondition
-            prev_node = node.prev
-            next_node = node.next
+          if key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
 
-            next_node.prev = prev_node if next_node
-            prev_node.next = next_node if prev_node
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
 
-            @first = next_node if @first == node
-            @last = prev_node  if @last  == node
+        alias_method :reject!, :delete_if
 
-            value = node.value
-          end
-
-          @hash.delete(key)
-          value
+        def reject(&block)
+          dup.reject!(&block)
         end
 
         def keys
-          map { |k, v| k }
+          @keys.dup
         end
 
         def values
-          map { |k, v| v }
+          @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 unless defined?(@first) && @first
-          yield [@first.key, @first.value]
-          node = @first
-          yield [node.key, node.value] while node = node.next # rubocop:disable AssignmentInCondition
+          return to_enum(:each) unless block_given?
+          @keys.each { |key| yield([key, self[key]]) }
           self
         end
 
-        def merge(other)
-          hash = self.class.new
+        def each_pair
+          return to_enum(:each_pair) unless block_given?
+          @keys.each { |key| yield(key, self[key]) }
+          self
+        end
 
-          each do |key, value|
-            hash[key] = value
-          end
+        alias_method :select, :find_all
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
 
-          other.each do |key, value|
-            hash[key] = value
+        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
 
-          hash
+        # 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 empty?
-          @hash.empty?
+        def inspect
+          "#<#{self.class} #{super}>"
+        end
+
+        private
+
+        def sync_keys!
+          @keys.delete_if { |k| !key?(k) }
         end
       end
     end

data/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/thor/lib/thor/group.rb

@@ -4,7 +4,7 @@ require "bundler/vendor/thor/lib/thor/base"
 # 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/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/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/bundler/lib/bundler/vendor/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