opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,16 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,81 +0,0 @@
-$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

@@ -1,76 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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