opal-connect-rspec 0.5.0

data/rspec-mocks/spec/support/before_all_shared_example_group.rb

@@ -0,0 +1,16 @@
+RSpec.shared_examples "fails in a before(:all) block" do
+  the_error = nil
+  before(:all) do
+    begin
+      use_rspec_mocks
+    rescue
+      the_error = $!
+    end
+  end
+
+  it "raises an error with a useful message" do
+    expect(the_error).to be_a_kind_of(RSpec::Mocks::OutsideOfExampleError)
+
+    expect(the_error.message).to match(/The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported./)
+  end
+end

data/rspec-mocks/spec/support/doubled_classes.rb

@@ -0,0 +1,74 @@
+class LoadedClass
+  extend RSpec::Support::RubyFeatures
+
+  M = :m
+  N = :n
+  INSTANCE = LoadedClass.new
+
+  class << self
+
+    def respond_to?(method_name, include_all = false)
+      return true if method_name == :dynamic_class_method
+      super
+    end
+
+    def defined_class_method
+    end
+
+    def send
+      # fake out!
+    end
+
+  protected
+
+    def defined_protected_class_method
+    end
+
+  private
+
+    def defined_private_class_method
+    end
+
+  end
+
+  def defined_instance_method
+  end
+
+  def instance_method_with_two_args(a, b)
+  end
+
+  def instance_method_with_only_defaults(a=1, b=2)
+  end
+
+  if required_kw_args_supported?
+    # Need to eval this since it is invalid syntax on earlier rubies.
+    eval <<-RUBY
+      def kw_args_method(foo, optional_arg:'hello', required_arg:)
+      end
+
+      def mixed_args_method(foo, bar, optional_arg_1:1, optional_arg_2:2)
+      end
+    RUBY
+  end
+
+  def send(*)
+  end
+
+  def respond_to?(method_name, include_all = false)
+    return true if method_name == :dynamic_instance_method
+    super
+  end
+
+  class Nested; end
+
+protected
+
+  def defined_protected_method
+  end
+
+private
+
+  def defined_private_method
+    "wink wink ;)"
+  end
+end

data/rspec-mocks/spec/support/matchers.rb

@@ -0,0 +1,15 @@
+module RSpec
+  module Matchers
+    def fail
+      raise_error(RSpec::Mocks::MockExpectationError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Mocks::MockExpectationError, message)
+    end
+
+    def fail_matching(message)
+      raise_error(RSpec::Mocks::MockExpectationError, (String === message ? /#{Regexp.escape(message)}/ : message))
+    end
+  end
+end

data/rspec-support/benchmarks/caller.rb

@@ -0,0 +1,81 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'benchmark'
+require 'rspec/support/caller_filter'
+
+n = 10000
+
+puts "#{n} times - ruby #{RUBY_VERSION}"
+puts
+
+puts "* Using a chunked fetch is quicker than the old method of array-access."
+Benchmark.bm(20) do |bm|
+  bm.report("CallerFilter") do
+    n.times do
+      RSpec::CallerFilter.first_non_rspec_line
+    end
+  end
+
+  bm.report("Direct caller access") do
+    n.times do
+      caller(1)[4]
+    end
+  end
+end
+
+puts
+puts "* Chunking fetches of caller adds a ~17% overhead."
+Benchmark.bm(20) do |bm|
+  bm.report("Chunked") do
+    n.times do
+      caller(1, 2)
+      caller(3, 2)
+      caller(5, 2)
+    end
+  end
+
+  bm.report("All at once") do
+    n.times do
+      caller(1, 6)
+    end
+  end
+end
+
+puts
+puts "* `caller` scales linearly with length parameter."
+Benchmark.bm(20) do |bm|
+  (1..10).each do |x|
+    bm.report(x) do
+      n.times do
+        caller(1, x)
+      end
+    end
+  end
+end
+
+
+# > ruby benchmarks/caller.rb
+# 10000 times - ruby 2.0.0
+#
+# * Using a chunked fetch is quicker than the old method of array-access.
+#                            user     system      total        real
+# CallerFilter            0.140000   0.010000   0.150000 (  0.145381)
+# Direct caller access   0.170000   0.000000   0.170000 (  0.180610)
+#
+# * Chunking fetches of caller adds a ~17% overhead.
+#                            user     system      total        real
+# Chunked                0.150000   0.000000   0.150000 (  0.181162)
+# All at once            0.130000   0.010000   0.140000 (  0.138732)
+#
+# * `caller` scales linearly with length parameter.
+#                            user     system      total        real
+# 1                      0.030000   0.000000   0.030000 (  0.035000)
+# 2                      0.050000   0.000000   0.050000 (  0.059879)
+# 3                      0.080000   0.000000   0.080000 (  0.098468)
+# 4                      0.090000   0.010000   0.100000 (  0.097619)
+# 5                      0.110000   0.000000   0.110000 (  0.126220)
+# 6                      0.130000   0.000000   0.130000 (  0.136739)
+# 7                      0.150000   0.000000   0.150000 (  0.159055)
+# 8                      0.160000   0.010000   0.170000 (  0.172416)
+# 9                      0.180000   0.000000   0.180000 (  0.203038)
+# 10                     0.200000   0.000000   0.200000 (  0.210551)

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

@@ -0,0 +1,76 @@
+module RSpec
+  module Support
+    # @api private
+    #
+    # Defines a helper method that is optimized to require files from the
+    # named lib. The passed block MUST be `{ |f| require_relative f }`
+    # because for `require_relative` to work properly from within the named
+    # lib the line of code must be IN that lib.
+    #
+    # `require_relative` is preferred when available because it is always O(1),
+    # regardless of the number of dirs in $LOAD_PATH. `require`, on the other
+    # hand, does a linear O(N) search over the dirs in the $LOAD_PATH until
+    # it can resolve the file relative to one of the dirs.
+    def self.define_optimized_require_for_rspec(lib, &require_relative)
+      name = "require_rspec_#{lib}"
+
+      if Kernel.respond_to?(:require_relative)
+        (class << self; self; end).__send__(:define_method, name) do |f|
+          require_relative.call("#{lib}/#{f}")
+        end
+      else
+        (class << self; self; end).__send__(:define_method, name) do |f|
+          require "rspec/#{lib}/#{f}"
+        end
+      end
+    end
+
+    define_optimized_require_for_rspec(:support) { |f| require_relative(f) }
+    require_rspec_support "version"
+    require_rspec_support "ruby_features"
+
+    # @api private
+    KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
+
+    # @api private
+    #
+    # Used internally to get a method handle for a particular object
+    # and method name.
+    #
+    # Includes handling for a few special cases:
+    #
+    #   - Objects that redefine #method (e.g. an HTTPRequest struct)
+    #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
+    #   - Objects that undefine method and delegate everything to another
+    #     object (e.g. Mongoid association objects)
+    if RubyFeatures.supports_rebinding_module_methods?
+      def self.method_handle_for(object, method_name)
+        KERNEL_METHOD_METHOD.bind(object).call(method_name)
+      rescue NameError => original
+        begin
+          handle = object.method(method_name)
+          raise original unless handle.is_a? Method
+          handle
+        rescue Exception
+          raise original
+        end
+      end
+    else
+      def self.method_handle_for(object, method_name)
+        if ::Kernel === object
+          KERNEL_METHOD_METHOD.bind(object).call(method_name)
+        else
+          object.method(method_name)
+        end
+      rescue NameError => original
+        begin
+          handle = object.method(method_name)
+          raise original unless handle.is_a? Method
+          handle
+        rescue Exception
+          raise original
+        end
+      end
+    end
+  end
+end

data/rspec-support/lib/rspec/support/caller_filter.rb

@@ -0,0 +1,63 @@
+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 RUBY_VERSION >= '2.0.0'
+      def self.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.
+
+        # Initial value here is mostly arbitrary, but is chosen to give good
+        # performance on the common case of creating a double.
+        increment = 5
+        i         = 1
+        line      = nil
+
+        until line
+          stack = caller(i, increment)
+          raise "No non-lib lines in stack" unless stack
+
+          line = stack.find { |l| l !~ IGNORE_REGEX }
+
+          i         += increment
+          increment *= 2 # The choice of two here is arbitrary.
+        end
+
+        line
+      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/rspec-support/lib/rspec/support/differ.rb

@@ -0,0 +1,214 @@
+RSpec::Support.require_rspec_support 'encoded_string'
+RSpec::Support.require_rspec_support 'hunk_generator'
+
+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 = pick_encoding actual, expected
+
+        @actual   = EncodedString.new(actual, @encoding)
+        @expected = EncodedString.new(expected, @encoding)
+
+        output = EncodedString.new("\n", @encoding)
+
+        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
+      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
+
+      attr_reader :color
+      alias_method :color?, :color
+
+      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 hunks
+        @hunks ||= 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
+          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")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object, "")
+        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
+      end
+
+      def handle_encoding_errors
+        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