sspec-support 3.8.0

data/lib/rspec/support/caller_filter.rb

@@ -0,0 +1,83 @@
+RSpec::Support.require_rspec_support "ruby_features"
+
+module RSpec
+  # Consistent implementation for "cleaning" the caller method to strip out
+  # non-rspec lines. This enables errors to be reported at the call site in
+  # the code using the library, which is far more useful than the particular
+  # internal method that raised an error.
+  class CallerFilter
+    RSPEC_LIBS = %w[
+      core
+      mocks
+      expectations
+      support
+      matchers
+      rails
+    ]
+
+    ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
+
+    LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
+
+    # rubygems/core_ext/kernel_require.rb isn't actually part of rspec (obviously) but we want
+    # it ignored when we are looking for the first meaningful line of the backtrace outside
+    # of RSpec. It can show up in the backtrace as the immediate first caller
+    # when `CallerFilter.first_non_rspec_line` is called from the top level of a required
+    # file, but it depends on if rubygems is loaded or not. We don't want to have to deal
+    # with this complexity in our `RSpec.deprecate` calls, so we ignore it here.
+    IGNORE_REGEX = Regexp.union(LIB_REGEX, "rubygems/core_ext/kernel_require.rb")
+
+    if RSpec::Support::RubyFeatures.caller_locations_supported?
+      # This supports args because it's more efficient when the caller specifies
+      # these. It allows us to skip frames the caller knows are part of RSpec,
+      # and to decrease the increment size if the caller is confident the line will
+      # be found in a small number of stack frames from `skip_frames`.
+      #
+      # Note that there is a risk to passing a `skip_frames` value that is too high:
+      # If it skippped the first non-rspec line, then this method would return the
+      # 2nd or 3rd (or whatever) non-rspec line. Thus, you generally shouldn't pass
+      # values for these parameters, particularly since most places that use this are
+      # not hot spots (generally it gets used for deprecation warnings). However,
+      # if you do have a hot spot that calls this, passing `skip_frames` can make
+      # a significant difference. Just make sure that that particular use is tested
+      # so that if the provided `skip_frames` changes to no longer be accurate in
+      # such a way that would return the wrong stack frame, a test will fail to tell you.
+      #
+      # See benchmarks/skip_frames_for_caller_filter.rb for measurements.
+      def self.first_non_rspec_line(skip_frames=3, increment=5)
+        # Why a default `skip_frames` of 3?
+        # By the time `caller_locations` is called below, the first 3 frames are:
+        #   lib/rspec/support/caller_filter.rb:63:in `block in first_non_rspec_line'
+        #   lib/rspec/support/caller_filter.rb:62:in `loop'
+        #   lib/rspec/support/caller_filter.rb:62:in `first_non_rspec_line'
+
+        # `caller` is an expensive method that scales linearly with the size of
+        # the stack. The performance hit for fetching it in chunks is small,
+        # and since the target line is probably near the top of the stack, the
+        # overall improvement of a chunked search like this is significant.
+        #
+        # See benchmarks/caller.rb for measurements.
+
+        # The default increment of 5 for this method are mostly arbitrary, but
+        # is chosen to give good performance on the common case of creating a double.
+
+        loop do
+          stack = caller_locations(skip_frames, increment)
+          raise "No non-lib lines in stack" unless stack
+
+          line = stack.find { |l| l.path !~ IGNORE_REGEX }
+          return line.to_s if line
+
+          skip_frames += increment
+          increment   *= 2 # The choice of two here is arbitrary.
+        end
+      end
+    else
+      # Earlier rubies do not support the two argument form of `caller`. This
+      # fallback is logically the same, but slower.
+      def self.first_non_rspec_line(*)
+        caller.find { |line| line !~ IGNORE_REGEX }
+      end
+    end
+  end
+end

data/lib/rspec/support/comparable_version.rb

@@ -0,0 +1,46 @@
+module RSpec
+  module Support
+    # @private
+    class ComparableVersion
+      include Comparable
+
+      attr_reader :string
+
+      def initialize(string)
+        @string = string
+      end
+
+      def <=>(other)
+        other = self.class.new(other) unless other.is_a?(self.class)
+
+        return 0 if string == other.string
+
+        longer_segment_count = [self, other].map { |version| version.segments.count }.max
+
+        longer_segment_count.times do |index|
+          self_segment = segments[index] || 0
+          other_segment = other.segments[index] || 0
+
+          if self_segment.class == other_segment.class
+            result = self_segment <=> other_segment
+            return result unless result == 0
+          else
+            return self_segment.is_a?(String) ? -1 : 1
+          end
+        end
+
+        0
+      end
+
+      def segments
+        @segments ||= string.scan(/[a-z]+|\d+/i).map do |segment|
+          if segment =~ /\A\d+\z/
+            segment.to_i
+          else
+            segment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/differ.rb

@@ -0,0 +1,215 @@
+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
+    class Differ
+      def diff(actual, expected)
+        diff = ""
+
+        if actual && expected
+          if all_strings?(actual, expected)
+            if any_multiline_strings?(actual, expected)
+              diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
+            end
+          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+            diff = diff_as_object(actual, expected)
+          end
+        end
+
+        diff.to_s
+      end
+
+      # rubocop:disable MethodLength
+      def diff_as_string(actual, expected)
+        encoding = EncodedString.pick_encoding(actual, expected)
+
+        actual   = EncodedString.new(actual, encoding)
+        expected = EncodedString.new(expected, encoding)
+
+        output = EncodedString.new("\n", encoding)
+        hunks = build_hunks(actual, expected)
+
+        hunks.each_cons(2) do |prev_hunk, current_hunk|
+          begin
+            if current_hunk.overlaps?(prev_hunk)
+              add_old_hunk_to_hunk(current_hunk, prev_hunk)
+            else
+              add_to_output(output, prev_hunk.diff(format_type).to_s)
+            end
+          ensure
+            add_to_output(output, "\n")
+          end
+        end
+
+        finalize_output(output, hunks.last.diff(format_type).to_s) if hunks.last
+
+        color_diff output
+      rescue Encoding::CompatibilityError
+        handle_encoding_errors(actual, expected)
+      end
+      # rubocop:enable MethodLength
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        diff_as_string(actual_as_string, expected_as_string)
+      end
+
+      def color?
+        @color
+      end
+
+      def initialize(opts={})
+        @color = opts.fetch(:color, false)
+        @object_preparer = opts.fetch(:object_preparer, lambda { |string| string })
+      end
+
+    private
+
+      def no_procs?(*args)
+        safely_flatten(args).none? { |a| Proc === a }
+      end
+
+      def all_strings?(*args)
+        safely_flatten(args).all? { |a| String === a }
+      end
+
+      def any_multiline_strings?(*args)
+        all_strings?(*args) && safely_flatten(args).any? { |a| multiline?(a) }
+      end
+
+      def no_numbers?(*args)
+        safely_flatten(args).none? { |a| Numeric === a }
+      end
+
+      def coerce_to_string(string_or_array)
+        return string_or_array unless Array === string_or_array
+        diffably_stringify(string_or_array).join("\n")
+      end
+
+      def diffably_stringify(array)
+        array.map do |entry|
+          if Array === entry
+            entry.inspect
+          else
+            entry.to_s.gsub("\n", "\\n")
+          end
+        end
+      end
+
+      if String.method_defined?(:encoding)
+        def multiline?(string)
+          string.include?("\n".encode(string.encoding))
+        end
+      else
+        def multiline?(string)
+          string.include?("\n")
+        end
+      end
+
+      def build_hunks(actual, expected)
+        HunkGenerator.new(actual, expected).hunks
+      end
+
+      def finalize_output(output, final_line)
+        add_to_output(output, final_line)
+        add_to_output(output, "\n")
+      end
+
+      def add_to_output(output, string)
+        output << string
+      end
+
+      def add_old_hunk_to_hunk(hunk, oldhunk)
+        hunk.merge(oldhunk)
+      end
+
+      def safely_flatten(array)
+        array = array.flatten(1) until (array == array.flatten(1))
+        array
+      end
+
+      def format_type
+        :unified
+      end
+
+      def color(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      def red(text)
+        color(text, 31)
+      end
+
+      def green(text)
+        color(text, 32)
+      end
+
+      def blue(text)
+        color(text, 34)
+      end
+
+      def normal(text)
+        color(text, 0)
+      end
+
+      def color_diff(diff)
+        return diff unless color?
+
+        diff.lines.map do |line|
+          case line[0].chr
+          when "+"
+            green line
+          when "-"
+            red line
+          when "@"
+            line[1].chr == "@" ? blue(line) : normal(line)
+          else
+            normal(line)
+          end
+        end.join
+      end
+
+      def object_to_string(object)
+        object = @object_preparer.call(object)
+        case object
+        when Hash
+          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, "".dup)
+        end
+      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(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})"
+        else
+          "Could not produce a diff because of the encoding of the string " \
+          "(#{expected.source_encoding})"
+        end
+      end
+    end
+    # rubocop:enable ClassLength
+  end
+end

data/lib/rspec/support/directory_maker.rb

@@ -0,0 +1,63 @@
+RSpec::Support.require_rspec_support 'ruby_features'
+
+module RSpec
+  module Support
+    # @api private
+    #
+    # Replacement for fileutils#mkdir_p because we don't want to require parts
+    # of stdlib in RSpec.
+    class DirectoryMaker
+      # @api private
+      #
+      # Implements nested directory construction
+      def self.mkdir_p(path)
+        stack = generate_stack(path)
+        path.split(File::SEPARATOR).each do |part|
+          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
+        end
+      end
+
+      if OS.windows_file_path?
+        def self.generate_stack(path)
+          if path.start_with?(File::SEPARATOR)
+            File::SEPARATOR
+          elsif path[1] == ':'
+            ''
+          else
+            '.'
+          end
+        end
+        def self.generate_path(stack, part)
+          if stack == ''
+            part
+          elsif stack == File::SEPARATOR
+            File.join('', part)
+          else
+            File.join(stack, part)
+          end
+        end
+      else
+        def self.generate_stack(path)
+          path.start_with?(File::SEPARATOR) ? File::SEPARATOR : "."
+        end
+        def self.generate_path(stack, part)
+          File.join(stack, part)
+        end
+      end
+
+      def self.directory_exists?(dirname)
+        File.exist?(dirname) && File.directory?(dirname)
+      end
+      private_class_method :directory_exists?
+      private_class_method :generate_stack
+      private_class_method :generate_path
+    end
+  end
+end

data/lib/rspec/support/encoded_string.rb

@@ -0,0 +1,165 @@
+module RSpec
+  module Support
+    # @private
+    class EncodedString
+      # Reduce allocations by storing constants.
+      UTF_8    = "UTF-8"
+      US_ASCII = "US-ASCII"
+      #
+      # 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"
+      #
+      # Ruby's default replacement string is:
+      #   U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else
+      #   ?      ("\x3F")
+      REPLACE = "?"
+      ENCODE_UNCONVERTABLE_BYTES =  {
+        :invalid => :replace,
+        :undef   => :replace,
+        :replace => REPLACE
+      }
+      ENCODE_NO_CONVERTER = {
+        :invalid => :replace,
+        :replace => REPLACE
+      }
+
+      def initialize(string, encoding=nil)
+        @encoding = encoding
+        @source_encoding = detect_source_encoding(string)
+        @string = matching_encoding(string)
+      end
+      attr_reader :source_encoding
+
+      delegated_methods = String.instance_methods.map(&:to_s) & %w[eql? lines == encoding empty?]
+      delegated_methods.each do |name|
+        define_method(name) { |*args, &block| @string.__send__(name, *args, &block) }
+      end
+
+      def <<(string)
+        @string << matching_encoding(string)
+      end
+
+      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
+        @string
+      end
+      alias :to_str :to_s
+
+      if String.method_defined?(:encoding)
+
+        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.compatibile?(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
+          string.encode(@encoding, ENCODE_UNCONVERTABLE_BYTES)
+        rescue Encoding::ConverterNotFoundError
+          string.dup.force_encoding(@encoding).encode(ENCODE_NO_CONVERTER)
+        end
+
+        # 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)
+          string
+        end
+
+        def detect_source_encoding(_string)
+          US_ASCII
+        end
+      end
+    end
+  end
+end