rspec-support 3.13.6 → 4.0.0.beta1

data/lib/rspec/support/method_signature_verifier.rb

@@ -10,7 +10,7 @@ module RSpec
     # keyword args of a given method.
     #
     # @private
-    class MethodSignature # rubocop:disable Metrics/ClassLength
+    class MethodSignature
       attr_reader :min_non_kw_args, :max_non_kw_args, :optional_kw_args, :required_kw_args
 
       def initialize(method)
@@ -47,141 +47,98 @@ module RSpec
         end
       end
 
-      if RubyFeatures.optional_and_splat_args_supported?
-        def description
-          @description ||= begin
-            parts = []
+      def description
+        @description ||= begin
+          parts = []
 
-            unless non_kw_args_arity_description == "0"
-              parts << "arity of #{non_kw_args_arity_description}"
-            end
-
-            if @optional_kw_args.any?
-              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            if @required_kw_args.any?
-              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            parts << "any additional keyword args" if @allows_any_kw_args
-
-            parts.join(" and ")
+          unless non_kw_args_arity_description == "0"
+            parts << "arity of #{non_kw_args_arity_description}"
           end
-        end
-
-        def missing_kw_args_from(given_kw_args)
-          @required_kw_args - given_kw_args
-        end
-
-        def invalid_kw_args_from(given_kw_args)
-          return [] if @allows_any_kw_args
-          given_kw_args - @allowed_kw_args
-        end
 
-        # Considering the arg types, are there kw_args?
-        if RubyFeatures.kw_arg_separation?
-          def has_kw_args_in?(args)
-            # If the last arg is a hash, depending on the signature it could be kw_args or a positional parameter.
-            return false unless Hash === args.last && could_contain_kw_args?(args)
-
-            # If the position of the hash is beyond the count of required and optional positional
-            # args then it is the kwargs hash
-            return true if args.count > @max_non_kw_args
-
-            # This is the proper way to disambiguate between positional args and keywords hash
-            # but relies on beginning of the call chain annotating the method with
-            # ruby2_keywords, so only use it for positive feedback as without the annotation
-            # this is always false
-            return true if Hash.ruby2_keywords_hash?(args[-1])
-
-            # Otherwise, the hash could be defined kw_args or an optional positional parameter
-            # inspect the keys against known kwargs to determine what it is
-            # Note: the problem with this is that if a user passes only invalid keyword args,
-            #       rspec no longer detects is and will assign this to a positional argument
-            return arbitrary_kw_args? || args.last.keys.all? { |x| @allowed_kw_args.include?(x) }
-          end
-        else
-          def has_kw_args_in?(args)
-            # Version <= Ruby 2.7
-            # If the last argument is Hash, Ruby will treat only symbol keys as keyword arguments
-            # the rest will be grouped in another Hash and passed as positional argument.
-            Hash === args.last &&
-              could_contain_kw_args?(args) &&
-              (args.last.empty? || args.last.keys.any? { |x| x.is_a?(Symbol) })
+          if @optional_kw_args.any?
+            parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
           end
-        end
-
-        # Without considering what the last arg is, could it
-        # contain keyword arguments?
-        def could_contain_kw_args?(args)
-          return false if args.count <= min_non_kw_args
 
-          @allows_any_kw_args || @allowed_kw_args.any?
-        end
+          if @required_kw_args.any?
+            parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
+          end
 
-        def arbitrary_kw_args?
-          @allows_any_kw_args
-        end
+          parts << "any additional keyword args" if @allows_any_kw_args
 
-        def unlimited_args?
-          @max_non_kw_args == INFINITY
+          parts.join(" and ")
         end
+      end
 
-        def classify_parameters
-          optional_non_kw_args = @min_non_kw_args = 0
-          @allows_any_kw_args = false
-
-          @method.parameters.each do |(type, name)|
-            case type
-            # def foo(a:)
-            when :keyreq  then @required_kw_args << name
-            # def foo(a: 1)
-            when :key     then @optional_kw_args << name
-            # def foo(**kw_args)
-            when :keyrest then @allows_any_kw_args = true
-            # def foo(a)
-            when :req     then @min_non_kw_args += 1
-            # def foo(a = 1)
-            when :opt     then optional_non_kw_args += 1
-            # def foo(*a)
-            when :rest    then optional_non_kw_args = INFINITY
-            end
-          end
+      def missing_kw_args_from(given_kw_args)
+        @required_kw_args - given_kw_args
+      end
 
-          @max_non_kw_args = @min_non_kw_args + optional_non_kw_args
-          @allowed_kw_args = @required_kw_args + @optional_kw_args
-        end
-      else
-        def description
-          "arity of #{non_kw_args_arity_description}"
-        end
+      def invalid_kw_args_from(given_kw_args)
+        return [] if @allows_any_kw_args
+        given_kw_args - @allowed_kw_args
+      end
 
-        def missing_kw_args_from(_given_kw_args)
-          []
-        end
+      # Considering the arg types, are there kw_args?
+      def has_kw_args_in?(args)
+        # If the last arg is a hash, depending on the signature it could be kw_args or a positional parameter.
+        return false unless Hash === args.last && could_contain_kw_args?(args)
+
+        # If the position of the hash is beyond the count of required and optional positional
+        # args then it is the kwargs hash
+        return true if args.count > @max_non_kw_args
+
+        # This is the proper way to disambiguate between positional args and keywords hash
+        # but relies on beginning of the call chain annotating the method with
+        # ruby2_keywords, so only use it for positive feedback as without the annotation
+        # this is always false
+        return true if Hash.ruby2_keywords_hash?(args[-1])
+
+        # Otherwise, the hash could be defined kw_args or an optional positional parameter
+        # inspect the keys against known kwargs to determine what it is
+        # Note: the problem with this is that if a user passes only invalid keyword args,
+        #       rspec no longer detects is and will assign this to a positional argument
+        return arbitrary_kw_args? || args.last.keys.all? { |x| @allowed_kw_args.include?(x) }
+      end
 
-        def invalid_kw_args_from(_given_kw_args)
-          []
-        end
+      # Without considering what the last arg is, could it
+      # contain keyword arguments?
+      def could_contain_kw_args?(args)
+        return false if args.count <= min_non_kw_args
 
-        def has_kw_args_in?(_args)
-          false
-        end
+        @allows_any_kw_args || @allowed_kw_args.any?
+      end
 
-        def could_contain_kw_args?(*)
-          false
-        end
+      def arbitrary_kw_args?
+        @allows_any_kw_args
+      end
 
-        def arbitrary_kw_args?
-          false
-        end
+      def unlimited_args?
+        @max_non_kw_args == INFINITY
+      end
 
-        def unlimited_args?
-          false
+      def classify_parameters
+        optional_non_kw_args = @min_non_kw_args = 0
+        @allows_any_kw_args = false
+
+        @method.parameters.each do |(type, name)|
+          case type
+          # def foo(a:)
+          when :keyreq  then @required_kw_args << name
+          # def foo(a: 1)
+          when :key     then @optional_kw_args << name
+          # def foo(**kw_args)
+          when :keyrest then @allows_any_kw_args = true
+          # def foo(a)
+          when :req     then @min_non_kw_args += 1
+          # def foo(a = 1)
+          when :opt     then optional_non_kw_args += 1
+          # def foo(*a)
+          when :rest    then optional_non_kw_args = INFINITY
+          end
         end
 
-        alias_method :classify_parameters, :classify_arity
+        @max_non_kw_args = @min_non_kw_args + optional_non_kw_args
+        @allowed_kw_args = @required_kw_args + @optional_kw_args
       end
 
       INFINITY = 1 / 0.0
@@ -190,8 +147,7 @@ module RSpec
     if RSpec::Support::Ruby.jruby?
       # JRuby has only partial support for UnboundMethod#parameters, so we fall back on using #arity
       # https://github.com/jruby/jruby/issues/2816 and https://github.com/jruby/jruby/issues/2817
-      if RubyFeatures.optional_and_splat_args_supported? &&
-         Java::JavaLang::String.instance_method(:char_at).parameters == []
+      if Java::JavaLang::String.instance_method(:char_at).parameters == []
 
         class MethodSignature < remove_const(:MethodSignature)
         private
@@ -277,7 +233,10 @@ module RSpec
       end
 
       def keywords=(values)
+        # until RSpec 4
+        # rubocop:disable Lint/UselessOr
         @keywords = values.to_a || []
+        # rubocop:enable Lint/UselessOr
       end
     end
 
@@ -291,11 +250,9 @@ module RSpec
     #
     # @api private
     class BlockSignature < MethodSignature
-      if RubyFeatures.optional_and_splat_args_supported?
-        def classify_parameters
-          super
-          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
-        end
+      def classify_parameters
+        super
+        @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
       end
     end
 
@@ -312,7 +269,7 @@ module RSpec
         @arbitrary_kw_args = @unlimited_args = false
       end
 
-      def with_expectation(expectation) # rubocop:disable Metrics/MethodLength
+      def with_expectation(expectation)
         return self unless MethodSignatureExpectation === expectation
 
         if expectation.empty?
@@ -322,19 +279,9 @@ module RSpec
           @min_non_kw_args = @non_kw_args = expectation.min_count || 0
           @max_non_kw_args                = expectation.max_count || @min_non_kw_args
 
-          if RubyFeatures.optional_and_splat_args_supported?
-            @unlimited_args = expectation.expect_unlimited_arguments
-          else
-            @unlimited_args = false
-          end
-
-          if RubyFeatures.kw_args_supported?
-            @kw_args           = expectation.keywords
-            @arbitrary_kw_args = expectation.expect_arbitrary_keywords
-          else
-            @kw_args           = []
-            @arbitrary_kw_args = false
-          end
+          @unlimited_args = expectation.expect_unlimited_arguments
+          @kw_args = expectation.keywords
+          @arbitrary_kw_args = expectation.expect_arbitrary_keywords
         end
 
         self
@@ -388,16 +335,7 @@ module RSpec
       end
 
       def split_args(args)
-        kw_args = if @signature.has_kw_args_in?(args) && !RubyFeatures.kw_arg_separation?
-                    last = args.pop
-                    non_kw_args = last.reject { |k, _| k.is_a?(Symbol) }
-                    if non_kw_args.empty?
-                      last.keys
-                    else
-                      args << non_kw_args
-                      last.select { |k, _| k.is_a?(Symbol) }.keys
-                    end
-                  elsif @signature.has_kw_args_in?(args) && RubyFeatures.kw_arg_separation?
+        kw_args = if @signature.has_kw_args_in?(args)
                     args.pop.keys
                   else
                     []

data/lib/rspec/support/object_formatter.rb

@@ -147,14 +147,8 @@ module RSpec
           Time === object
         end
 
-        if Time.method_defined?(:nsec)
-          def inspect
-            object.strftime("#{FORMAT}.#{"%09d" % object.nsec} %z")
-          end
-        else # for 1.8.7
-          def inspect
-            object.strftime("#{FORMAT}.#{"%06d" % object.usec} %z")
-          end
+        def inspect
+          object.strftime("#{FORMAT}.#{"%09d" % object.nsec} %z")
         end
       end
 
@@ -176,16 +170,6 @@ module RSpec
         end
       end
 
-      class BigDecimalInspector < BaseInspector
-        def self.can_inspect?(object)
-          defined?(BigDecimal) && BigDecimal === object
-        end
-
-        def inspect
-          "#{object.to_s('F')} (#{object.inspect})"
-        end
-      end
-
       class DescribableMatcherInspector < BaseInspector
         def self.can_inspect?(object)
           Support.is_a_matcher?(object) && object.respond_to?(:description)
@@ -217,9 +201,6 @@ module RSpec
         # http://stackoverflow.com/a/2818916
         def native_object_id
           OBJECT_ID_FORMAT % (object.__id__ << 1)
-        rescue NoMethodError
-          # In Ruby 1.9.2, BasicObject responds to none of #__id__, #object_id, #id...
-          '-'
         end
       end
 
@@ -249,17 +230,11 @@ module RSpec
       INSPECTOR_CLASSES = [
         TimeInspector,
         DateTimeInspector,
-        BigDecimalInspector,
         UninspectableObjectInspector,
         DescribableMatcherInspector,
         DelegatorInspector,
         InspectableObjectInspector
-      ].tap do |classes|
-        # 2.4 has improved BigDecimal formatting so we do not need
-        # to provide our own.
-        # https://github.com/ruby/bigdecimal/pull/42
-        classes.delete(BigDecimalInspector) if RUBY_VERSION >= '2.4'
-      end
+      ]
 
     private
 

data/lib/rspec/support/recursive_const_methods.rb

@@ -7,52 +7,29 @@ module RSpec
     module RecursiveConstMethods
       # We only want to consider constants that are defined directly on a
       # particular module, and not include top-level/inherited constants.
-      # Unfortunately, the constant API changed between 1.8 and 1.9, so
-      # we need to conditionally define methods to ignore the top-level/inherited
-      # constants.
       #
       # Given:
       #   class A; B = 1; end
       #   class C < A; end
       #
-      # On 1.8:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => false
-      #   - C.constants # => ["B"]
-      #   - None of these methods accept the extra `inherit` argument
-      # On 1.9:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => true
-      #   - C.const_get("Hash", false) # => raises NameError
-      #   - C.const_defined?("Hash", false) # => false
-      #   - C.constants # => [:B]
-      #   - C.constants(false) #=> []
-      if Module.method(:const_defined?).arity == 1
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
-
-          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
-        end
-
-        def constants_defined_on(mod)
-          mod.constants.select { |c| const_defined_on?(mod, c) }
-        end
-      else
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name, false)
-        end
+      # Then:
+      #   C.const_get("Hash") # => ::Hash
+      #   C.const_defined?("Hash") # => true
+      #   C.const_get("Hash", false) # => raises NameError
+      #   C.const_defined?("Hash", false) # => false
+      #   C.constants # => [:B]
+      #   C.constants(false) #=> []
+
+      def const_defined_on?(mod, const_name)
+        mod.const_defined?(const_name, false)
+      end
 
-        def get_const_defined_on(mod, const_name)
-          mod.const_get(const_name, false)
-        end
+      def get_const_defined_on(mod, const_name)
+        mod.const_get(const_name, false)
+      end
 
-        def constants_defined_on(mod)
-          mod.constants(false)
-        end
+      def constants_defined_on(mod)
+        mod.constants(false)
       end
 
       def recursive_const_get(const_name)

data/lib/rspec/support/reentrant_mutex.rb

@@ -2,16 +2,20 @@
 
 module RSpec
   module Support
+    # This class protects us against Mutex.new stubbed out within tests.
+    # @private
+    class Mutex < ::Mutex
+      class << self
+        define_method(:new, &::Mutex.method(:new))
+      end
+    end
+
     # Allows a thread to lock out other threads from a critical section of code,
     # while allowing the thread with the lock to reenter that section.
     #
     # Based on Monitor as of 2.2 -
     # https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
     #
-    # Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
-    #   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
-    #   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
-    #
     # @private
     class ReentrantMutex
       def initialize
@@ -29,52 +33,18 @@ module RSpec
 
     private
 
-      # This is fixing a bug #501 that is specific to Ruby 3.0. The new implementation
-      # depends on `owned?` that was introduced in Ruby 2.0, so both should work for Ruby 2.x.
-      if RUBY_VERSION.to_f >= 3.0
-        def enter
-          @mutex.lock unless @mutex.owned?
-          @count += 1
-        end
-
-        def exit
-          unless @mutex.owned?
-            raise ThreadError, "Attempt to unlock a mutex which is locked by another thread/fiber"
-          end
-          @count -= 1
-          @mutex.unlock if @count == 0
-        end
-      else
-        def enter
-          @mutex.lock if @owner != Thread.current
-          @owner = Thread.current
-          @count += 1
-        end
-
-        def exit
-          @count -= 1
-          return unless @count == 0
-          @owner = nil
-          @mutex.unlock
-        end
+      def enter
+        @mutex.lock unless @mutex.owned?
+        @count += 1
       end
-    end
-
-    if defined? ::Mutex
-      # On 1.9 and up, this is in core, so we just use the real one
-      class Mutex < ::Mutex
-        # If you mock Mutex.new you break our usage of Mutex, so
-        # instead we capture the original method to return Mutexes.
-        NEW_MUTEX_METHOD = Mutex.method(:new)
 
-        def self.new
-          NEW_MUTEX_METHOD.call
+      def exit
+        unless @mutex.owned?
+          raise ThreadError, "Attempt to unlock a mutex which is locked by another thread/fiber"
         end
+        @count -= 1
+        @mutex.unlock if @count == 0
       end
-    else # For 1.8.7
-      # :nocov:
-      RSpec::Support.require_rspec_support "mutex"
-      # :nocov:
     end
   end
 end