opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-support/upstream/lib/rspec/support/differ.rb

@@ -1,16 +1,17 @@
 RSpec::Support.require_rspec_support 'encoded_string'
 RSpec::Support.require_rspec_support 'hunk_generator'
+RSpec::Support.require_rspec_support "object_formatter"
 
 require 'pp'
 
 module RSpec
   module Support
-    # rubocop:disable ClassLength
+    # rubocop:disable Metrics/ClassLength
     class Differ
       def diff(actual, expected)
         diff = ""
 
-        if actual && expected
+        unless actual.nil? || expected.nil?
           if all_strings?(actual, expected)
             if any_multiline_strings?(actual, expected)
               diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
@@ -23,14 +24,15 @@ module RSpec
         diff.to_s
       end
 
-      # rubocop:disable MethodLength
+      # rubocop:disable Metrics/MethodLength
       def diff_as_string(actual, expected)
-        @encoding = pick_encoding actual, expected
+        encoding = EncodedString.pick_encoding(actual, expected)
 
-        @actual   = EncodedString.new(actual, @encoding)
-        @expected = EncodedString.new(expected, @encoding)
+        actual   = EncodedString.new(actual, encoding)
+        expected = EncodedString.new(expected, encoding)
 
-        output = EncodedString.new("\n", @encoding)
+        output = EncodedString.new("\n", encoding)
+        hunks = build_hunks(actual, expected)
 
         hunks.each_cons(2) do |prev_hunk, current_hunk|
           begin
@@ -48,9 +50,9 @@ module RSpec
 
         color_diff output
       rescue Encoding::CompatibilityError
-        handle_encoding_errors
+        handle_encoding_errors(actual, expected)
       end
-      # rubocop:enable MethodLength
+      # rubocop:enable Metrics/MethodLength
 
       def diff_as_object(actual, expected)
         actual_as_string = object_to_string(actual)
@@ -58,8 +60,9 @@ module RSpec
         diff_as_string(actual_as_string, expected_as_string)
       end
 
-      attr_reader :color
-      alias_method :color?, :color
+      def color?
+        @color
+      end
 
       def initialize(opts={})
         @color = opts.fetch(:color, false)
@@ -94,7 +97,7 @@ module RSpec
           if Array === entry
             entry.inspect
           else
-            entry.to_s.gsub("\n", "\\n")
+            entry.to_s.gsub("\n", "\\n").gsub("\r", "\\r")
           end
         end
       end
@@ -109,8 +112,8 @@ module RSpec
         end
       end
 
-      def hunks
-        @hunks ||= HunkGenerator.new(@actual, @expected).hunks
+      def build_hunks(actual, expected)
+        HunkGenerator.new(actual, expected).hunks
       end
 
       def finalize_output(output, final_line)
@@ -176,39 +179,37 @@ module RSpec
         object = @object_preparer.call(object)
         case object
         when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |key|
-            pp_key   = PP.singleline_pp(key, "")
-            pp_value = PP.singleline_pp(object[key], "")
-
-            "#{pp_key} => #{pp_value},"
-          end.join("\n")
+          hash_to_string(object)
+        when Array
+          PP.pp(ObjectFormatter.prepare_for_inspection(object), "".dup)
         when String
           object =~ /\n/ ? object : object.inspect
         else
-          PP.pp(object, "")
+          PP.pp(object, "".dup)
         end
       end
 
-      if String.method_defined?(:encoding)
-        def pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-      else
-        def pick_encoding(_source_a, _source_b)
-        end
+      def hash_to_string(hash)
+        formatted_hash = ObjectFormatter.prepare_for_inspection(hash)
+        formatted_hash.keys.sort_by { |k| k.to_s }.map do |key|
+          pp_key   = PP.singleline_pp(key, "".dup)
+          pp_value = PP.singleline_pp(formatted_hash[key], "".dup)
+
+          "#{pp_key} => #{pp_value},"
+        end.join("\n")
       end
 
-      def handle_encoding_errors
-        if @actual.source_encoding != @expected.source_encoding
+      def handle_encoding_errors(actual, expected)
+        if actual.source_encoding != expected.source_encoding
           "Could not produce a diff because the encoding of the actual string " \
-          "(#{@actual.source_encoding}) differs from the encoding of the expected " \
-          "string (#{@expected.source_encoding})"
+          "(#{actual.source_encoding}) differs from the encoding of the expected " \
+          "string (#{expected.source_encoding})"
         else
           "Could not produce a diff because of the encoding of the string " \
-          "(#{@expected.source_encoding})"
+          "(#{expected.source_encoding})"
         end
       end
     end
-    # rubocop:enable ClassLength
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/rspec-support/upstream/lib/rspec/support/directory_maker.rb

@@ -1,4 +1,4 @@
-RSpec::Support.require_rspec_support 'os'
+RSpec::Support.require_rspec_support 'ruby_features'
 
 module RSpec
   module Support
@@ -16,6 +16,8 @@ module RSpec
           stack = generate_path(stack, part)
           begin
             Dir.mkdir(stack) unless directory_exists?(stack)
+          rescue Errno::EEXIST => e
+            raise e unless directory_exists?(stack)
           rescue Errno::ENOTDIR => e
             raise Errno::EEXIST, e.message
           end

data/rspec-support/upstream/lib/rspec/support/encoded_string.rb

@@ -2,7 +2,14 @@ module RSpec
   module Support
     # @private
     class EncodedString
-      MRI_UNICODE_UNKOWN_CHARACTER = "\xEF\xBF\xBD"
+      # Reduce allocations by storing constants.
+      UTF_8    = "UTF-8"
+      US_ASCII = "US-ASCII"
+
+      # Ruby's default replacement string is:
+      #   U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else
+      #   ?      ("\x3F")
+      REPLACE = "?"
 
       def initialize(string, encoding=nil)
         @encoding = encoding
@@ -20,8 +27,18 @@ module RSpec
         @string << matching_encoding(string)
       end
 
-      def split(regex_or_string)
-        @string.split(matching_encoding(regex_or_string))
+      if Ruby.jruby?
+        def split(regex_or_string)
+          @string.split(matching_encoding(regex_or_string))
+        rescue ArgumentError
+          # JRuby raises an ArgumentError when splitting a source string that
+          # contains invalid bytes.
+          remove_invalid_bytes(@string).split regex_or_string
+        end
+      else
+        def split(regex_or_string)
+          @string.split(matching_encoding(regex_or_string))
+        end
       end
 
       def to_s
@@ -33,27 +50,102 @@ module RSpec
 
         private
 
+        # Encoding Exceptions:
+        #
+        # Raised by Encoding and String methods:
+        #   Encoding::UndefinedConversionError:
+        #     when a transcoding operation fails
+        #     if the String contains characters invalid for the target encoding
+        #     e.g. "\x80".encode('UTF-8','ASCII-8BIT')
+        #     vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>')
+        #     # => '<undef>'
+        #   Encoding::CompatibilityError
+        #     when Encoding.compatible?(str1, str2) is nil
+        #     e.g. utf_16le_emoji_string.split("\n")
+        #     e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string
+        #   Encoding::InvalidByteSequenceError:
+        #     when the string being transcoded contains a byte invalid for
+        #     either the source or target encoding
+        #     e.g. "\x80".encode('UTF-8','US-ASCII')
+        #     vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>')
+        #     # => '<byte>'
+        #   ArgumentError
+        #     when operating on a string with invalid bytes
+        #     e.g."\x80".split("\n")
+        #   TypeError
+        #     when a symbol is passed as an encoding
+        #     Encoding.find(:"UTF-8")
+        #     when calling force_encoding on an object
+        #     that doesn't respond to #to_str
+        #
+        # Raised by transcoding methods:
+        #   Encoding::ConverterNotFoundError:
+        #     when a named encoding does not correspond with a known converter
+        #     e.g. 'abc'.force_encoding('UTF-8').encode('foo')
+        #     or a converter path cannot be found
+        #     e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule')
+        #
+        # Raised by byte <-> char conversions
+        #   RangeError: out of char range
+        #     e.g. the UTF-16LE emoji: 128169.chr
         def matching_encoding(string)
+          string = remove_invalid_bytes(string)
           string.encode(@encoding)
         rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          normalize_missing(string.encode(@encoding, :invalid => :replace, :undef => :replace))
+          # Originally defined as a constant to avoid unneeded allocations, this hash must
+          # be defined inline (without {}) to avoid warnings on Ruby 2.7
+          #
+          # In MRI 2.1 'invalid: :replace' changed to also replace an invalid byte sequence
+          # see https://github.com/ruby/ruby/blob/v2_1_0/NEWS#L176
+          # https://www.ruby-forum.com/topic/6861247
+          # https://twitter.com/nalsh/status/553413844685438976
+          #
+          # For example, given:
+          #   "\x80".force_encoding("Emacs-Mule").encode(:invalid => :replace).bytes.to_a
+          #
+          # On MRI 2.1 or above: 63  # '?'
+          # else               : 128 # "\x80"
+          #
+          string.encode(@encoding, :invalid => :replace, :undef => :replace, :replace => REPLACE)
         rescue Encoding::ConverterNotFoundError
-          normalize_missing(string.force_encoding(@encoding).encode(:invalid => :replace))
+          # Originally defined as a constant to avoid unneeded allocations, this hash must
+          # be defined inline (without {}) to avoid warnings on Ruby 2.7
+          string.dup.force_encoding(@encoding).encode(:invalid => :replace, :replace => REPLACE)
         end
 
-        def normalize_missing(string)
-          if @encoding.to_s == "UTF-8"
-            string.gsub(MRI_UNICODE_UNKOWN_CHARACTER.force_encoding(@encoding), "?")
-          else
-            string
+        # Prevents raising ArgumentError
+        if String.method_defined?(:scrub)
+          # https://github.com/ruby/ruby/blob/eeb05e8c11/doc/NEWS-2.1.0#L120-L123
+          # https://github.com/ruby/ruby/blob/v2_1_0/string.c#L8242
+          # https://github.com/hsbt/string-scrub
+          # https://github.com/rubinius/rubinius/blob/v2.5.2/kernel/common/string.rb#L1913-L1972
+          def remove_invalid_bytes(string)
+            string.scrub(REPLACE)
+          end
+        else
+          # http://stackoverflow.com/a/8711118/879854
+          # Loop over chars in a string replacing chars
+          # with invalid encoding, which is a pretty good proxy
+          # for the invalid byte sequence that causes an ArgumentError
+          def remove_invalid_bytes(string)
+            string.chars.map do |char|
+              char.valid_encoding? ? char : REPLACE
+            end.join
           end
         end
 
         def detect_source_encoding(string)
           string.encoding
         end
+
+        def self.pick_encoding(source_a, source_b)
+          Encoding.compatible?(source_a, source_b) || Encoding.default_external
+        end
       else
 
+        def self.pick_encoding(_source_a, _source_b)
+        end
+
         private
 
         def matching_encoding(string)
@@ -61,7 +153,7 @@ module RSpec
         end
 
         def detect_source_encoding(_string)
-          'US-ASCII'
+          US_ASCII
         end
       end
     end

data/rspec-support/upstream/lib/rspec/support/fuzzy_matcher.rb

@@ -6,14 +6,14 @@ module RSpec
     module FuzzyMatcher
       # @api private
       def self.values_match?(expected, actual)
-        if Array === expected && Enumerable === actual && !(Struct === actual)
+        if Hash === actual
+          return hashes_match?(expected, actual) if Hash === expected
+        elsif Array === expected && Enumerable === actual && !(Struct === actual)
           return arrays_match?(expected, actual.to_a)
-        elsif Hash === expected && Hash === actual
-          return hashes_match?(expected, actual)
-        elsif actual == expected
-          return true
         end
 
+        return true if expected == actual
+
         begin
           expected === actual
         rescue ArgumentError

data/rspec-support/upstream/lib/rspec/support/matcher_definition.rb

@@ -27,5 +27,16 @@ module RSpec
     def self.is_a_matcher?(object)
       matcher_definitions.any? { |md| md.call(object) }
     end
+
+    # @api private
+    #
+    # gives a string representation of an object for use in RSpec descriptions
+    def self.rspec_description_for_object(object)
+      if RSpec::Support.is_a_matcher?(object) && object.respond_to?(:description)
+        object.description
+      else
+        object
+      end
+    end
   end
 end

data/rspec-support/upstream/lib/rspec/support/method_signature_verifier.rb

@@ -8,11 +8,13 @@ module RSpec
     # keyword args of a given method.
     #
     # @private
-    class MethodSignature
-      attr_reader :min_non_kw_args, :max_non_kw_args
+    class MethodSignature # rubocop:disable Metrics/ClassLength
+      attr_reader :min_non_kw_args, :max_non_kw_args, :optional_kw_args, :required_kw_args
 
       def initialize(method)
-        @method = method
+        @method           = method
+        @optional_kw_args = []
+        @required_kw_args = []
         classify_parameters
       end
 
@@ -24,9 +26,23 @@ module RSpec
         end
       end
 
-      def valid_non_kw_args?(positional_arg_count)
+      def valid_non_kw_args?(positional_arg_count, optional_max_arg_count=positional_arg_count)
+        return true if positional_arg_count.nil?
+
         min_non_kw_args <= positional_arg_count &&
-          positional_arg_count <= max_non_kw_args
+          optional_max_arg_count <= max_non_kw_args
+      end
+
+      def classify_arity(arity=@method.arity)
+        if arity < 0
+          # `~` inverts the one's complement and gives us the
+          # number of required args
+          @min_non_kw_args = ~arity
+          @max_non_kw_args = INFINITY
+        else
+          @min_non_kw_args = arity
+          @max_non_kw_args = arity
+        end
       end
 
       if RubyFeatures.optional_and_splat_args_supported?
@@ -61,20 +77,32 @@ module RSpec
           given_kw_args - @allowed_kw_args
         end
 
+        # 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.
         def has_kw_args_in?(args)
-          Hash === args.last && could_contain_kw_args?(args)
+          Hash === args.last &&
+            could_contain_kw_args?(args) &&
+            (args.last.empty? || args.last.keys.any? { |x| x.is_a?(Symbol) })
         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
 
+        def arbitrary_kw_args?
+          @allows_any_kw_args
+        end
+
+        def unlimited_args?
+          @max_non_kw_args == INFINITY
+        end
+
         def classify_parameters
           optional_non_kw_args = @min_non_kw_args = 0
-          @optional_kw_args, @required_kw_args = [], []
           @allows_any_kw_args = false
 
           @method.parameters.each do |(type, name)|
@@ -94,7 +122,7 @@ module RSpec
             end
           end
 
-          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
+          @max_non_kw_args = @min_non_kw_args + optional_non_kw_args
           @allowed_kw_args = @required_kw_args + @optional_kw_args
         end
       else
@@ -118,23 +146,114 @@ module RSpec
           false
         end
 
-        def classify_parameters
-          arity = @method.arity
-          if arity < 0
-            # `~` inverts the one's complement and gives us the
-            # number of required args
-            @min_non_kw_args = ~arity
-            @max_non_kw_args = INFINITY
-          else
-            @min_non_kw_args = arity
-            @max_non_kw_args = arity
-          end
+        def arbitrary_kw_args?
+          false
+        end
+
+        def unlimited_args?
+          false
         end
+
+        alias_method :classify_parameters, :classify_arity
       end
 
       INFINITY = 1 / 0.0
     end
 
+    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 == []
+
+        class MethodSignature < remove_const(:MethodSignature)
+        private
+
+          def classify_parameters
+            super
+            if (arity = @method.arity) != 0 && @method.parameters.empty?
+              classify_arity(arity)
+            end
+          end
+        end
+      end
+
+      # JRuby used to always report -1 arity for Java proxy methods.
+      # The workaround essentially makes use of Java's introspection to figure
+      # out matching methods (which could be more than one partly because Java
+      # supports multiple overloads, and partly because JRuby introduces
+      # aliases to make method names look more Rubyesque). If there is only a
+      # single match, we can use that methods arity directly instead of the
+      # default -1 arity.
+      #
+      # This workaround only works for Java proxy methods, and in order to
+      # support regular methods and blocks, we need to be careful about calling
+      # owner and java_class as they might not be available
+      if Java::JavaLang::String.instance_method(:char_at).arity == -1
+        class MethodSignature < remove_const(:MethodSignature)
+        private
+
+          def classify_parameters
+            super
+            return unless @method.arity == -1
+            return unless @method.respond_to?(:owner)
+            return unless @method.owner.respond_to?(:java_class)
+            java_instance_methods = @method.owner.java_class.java_instance_methods
+            compatible_overloads = java_instance_methods.select do |java_method|
+              @method == @method.owner.instance_method(java_method.name)
+            end
+            if compatible_overloads.size == 1
+              classify_arity(compatible_overloads.first.arity)
+            end
+          end
+        end
+      end
+    end
+
+    # Encapsulates expectations about the number of arguments and
+    # allowed/required keyword args of a given method.
+    #
+    # @api private
+    class MethodSignatureExpectation
+      def initialize
+        @min_count = nil
+        @max_count = nil
+        @keywords  = []
+
+        @expect_unlimited_arguments = false
+        @expect_arbitrary_keywords  = false
+      end
+
+      attr_reader :min_count, :max_count, :keywords
+
+      attr_accessor :expect_unlimited_arguments, :expect_arbitrary_keywords
+
+      def max_count=(number)
+        raise ArgumentError, 'must be a non-negative integer or nil' \
+          unless number.nil? || (number.is_a?(Integer) && number >= 0)
+
+        @max_count = number
+      end
+
+      def min_count=(number)
+        raise ArgumentError, 'must be a non-negative integer or nil' \
+          unless number.nil? || (number.is_a?(Integer) && number >= 0)
+
+        @min_count = number
+      end
+
+      def empty?
+        @min_count.nil? &&
+          @keywords.to_a.empty? &&
+          !@expect_arbitrary_keywords &&
+          !@expect_unlimited_arguments
+      end
+
+      def keywords=(values)
+        @keywords = values.to_a || []
+      end
+    end
+
     # Deals with the slightly different semantics of block arguments.
     # For methods, arguments are required unless a default value is provided.
     # For blocks, arguments are optional, even if no default value is provided.
@@ -157,17 +276,49 @@ module RSpec
     #
     # @api private
     class MethodSignatureVerifier
-      attr_reader :non_kw_args, :kw_args
+      attr_reader :non_kw_args, :kw_args, :min_non_kw_args, :max_non_kw_args
 
-      def initialize(signature, args)
+      def initialize(signature, args=[])
         @signature = signature
         @non_kw_args, @kw_args = split_args(*args)
+        @min_non_kw_args = @max_non_kw_args = @non_kw_args
+        @arbitrary_kw_args = @unlimited_args = false
+      end
+
+      def with_expectation(expectation) # rubocop:disable Metrics/MethodLength
+        return self unless MethodSignatureExpectation === expectation
+
+        if expectation.empty?
+          @min_non_kw_args = @max_non_kw_args = @non_kw_args = nil
+          @kw_args     = []
+        else
+          @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
+        end
+
+        self
       end
 
       def valid?
         missing_kw_args.empty? &&
           invalid_kw_args.empty? &&
-          valid_non_kw_args?
+          valid_non_kw_args? &&
+          arbitrary_kw_args? &&
+          unlimited_args?
       end
 
       def error_message
@@ -182,7 +333,7 @@ module RSpec
         elsif !valid_non_kw_args?
           "Wrong number of arguments. Expected %s, got %s." % [
             @signature.non_kw_args_arity_description,
-            non_kw_args.length
+            non_kw_args
           ]
         end
       end
@@ -190,7 +341,7 @@ module RSpec
     private
 
       def valid_non_kw_args?
-        @signature.valid_non_kw_args?(non_kw_args.length)
+        @signature.valid_non_kw_args?(min_non_kw_args, max_non_kw_args)
       end
 
       def missing_kw_args
@@ -201,14 +352,29 @@ module RSpec
         @signature.invalid_kw_args_from(kw_args)
       end
 
+      def arbitrary_kw_args?
+        !@arbitrary_kw_args || @signature.arbitrary_kw_args?
+      end
+
+      def unlimited_args?
+        !@unlimited_args || @signature.unlimited_args?
+      end
+
       def split_args(*args)
         kw_args = if @signature.has_kw_args_in?(args)
-                    args.pop.keys
+                    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
                   else
                     []
                   end
 
-        [args, kw_args]
+        [args.length, kw_args]
       end
     end