opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-mocks/spec/spec_helper.rb

@@ -0,0 +1,131 @@
+require 'rspec/support/spec'
+require 'rspec/support/ruby_features'
+
+RSpec::Support::Spec.setup_simplecov do
+  minimum_coverage 95
+end
+
+require 'yaml'
+begin
+  require 'psych'
+rescue LoadError
+end
+
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+require 'support/matchers'
+
+module VerifyAndResetHelpers
+  def verify(object)
+    proxy = RSpec::Mocks.space.proxy_for(object)
+    proxy.verify
+  ensure
+    proxy.reset # so it doesn't fail the verify after the example completes
+  end
+
+  def reset(object)
+    RSpec::Mocks.space.proxy_for(object).reset
+  end
+
+  def verify_all
+    RSpec::Mocks.space.verify_all
+  ensure
+    reset_all
+  end
+
+  def reset_all
+    RSpec::Mocks.space.reset_all
+  end
+end
+
+module VerificationHelpers
+  def prevents(msg = //, &block)
+    expect(&block).to \
+      raise_error(RSpec::Mocks::MockExpectationError, msg)
+  end
+end
+
+require 'rspec/support/spec'
+
+RSpec.configure do |config|
+  config.expose_dsl_globally = false
+  config.mock_with :rspec
+  config.color = true
+  config.order = :random
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    $default_rspec_mocks_syntax = mocks.syntax
+    mocks.syntax = :expect
+  end
+
+  old_verbose = nil
+  config.before(:each, :silence_warnings) do
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+  end
+
+  config.after(:each, :silence_warnings) do
+    $VERBOSE = old_verbose
+  end
+
+  config.include VerifyAndResetHelpers
+  config.include VerificationHelpers
+  config.extend RSpec::Support::RubyFeatures
+  config.include RSpec::Support::RubyFeatures
+end
+
+RSpec.shared_context "with syntax" do |syntax|
+  orig_syntax = nil
+
+  before(:all) do
+    orig_syntax = RSpec::Mocks.configuration.syntax
+    RSpec::Mocks.configuration.syntax = syntax
+  end
+
+  after(:all) do
+    RSpec::Mocks.configuration.syntax = orig_syntax
+  end
+end
+
+
+RSpec.shared_context "with isolated configuration" do
+  orig_configuration = nil
+  before do
+    orig_configuration = RSpec::Mocks.configuration
+    RSpec::Mocks.instance_variable_set(:@configuration, RSpec::Mocks::Configuration.new)
+  end
+
+  after do
+    RSpec::Mocks.instance_variable_set(:@configuration, orig_configuration)
+  end
+end
+
+RSpec.shared_context "with monkey-patched marshal" do
+  before do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
+  end
+
+  after do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = false
+  end
+end
+
+RSpec.shared_context "with the default mocks syntax" do
+  orig_syntax = nil
+
+  before(:all) do
+    orig_syntax = RSpec::Mocks.configuration.syntax
+    RSpec::Mocks.configuration.reset_syntaxes_to_default
+  end
+
+  after(:all) do
+    RSpec::Mocks.configuration.syntax = orig_syntax
+  end
+end

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/{vendor_lib → rspec-support/lib}/rspec/support/caller_filter.rb

@@ -4,7 +4,6 @@ module RSpec
   # 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
@@ -18,6 +17,14 @@ module RSpec
 
     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
@@ -33,11 +40,11 @@ module RSpec
         i         = 1
         line      = nil
 
-        while !line
+        until line
           stack = caller(i, increment)
           raise "No non-lib lines in stack" unless stack
 
-          line = stack.find { |l| l !~ LIB_REGEX }
+          line = stack.find { |l| l !~ IGNORE_REGEX }
 
           i         += increment
           increment *= 2 # The choice of two here is arbitrary.
@@ -49,7 +56,7 @@ module RSpec
       # 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 !~ LIB_REGEX }
+        caller.find { |line| line !~ IGNORE_REGEX }
       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

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

@@ -0,0 +1,61 @@
+RSpec::Support.require_rspec_support 'os'
+
+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::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/rspec-support/lib/rspec/support/encoded_string.rb

@@ -0,0 +1,69 @@
+module RSpec
+  module Support
+    # @private
+    class EncodedString
+      MRI_UNICODE_UNKOWN_CHARACTER = "\xEF\xBF\xBD"
+
+      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
+
+      def split(regex_or_string)
+        @string.split(matching_encoding(regex_or_string))
+      end
+
+      def to_s
+        @string
+      end
+      alias :to_str :to_s
+
+      if String.method_defined?(:encoding)
+
+        private
+
+        def matching_encoding(string)
+          string.encode(@encoding)
+        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+          normalize_missing(string.encode(@encoding, :invalid => :replace, :undef => :replace))
+        rescue Encoding::ConverterNotFoundError
+          normalize_missing(string.force_encoding(@encoding).encode(:invalid => :replace))
+        end
+
+        def normalize_missing(string)
+          if @encoding.to_s == "UTF-8"
+            string.gsub(MRI_UNICODE_UNKOWN_CHARACTER.force_encoding(@encoding), "?")
+          else
+            string
+          end
+        end
+
+        def detect_source_encoding(string)
+          string.encoding
+        end
+      else
+
+        private
+
+        def matching_encoding(string)
+          string
+        end
+
+        def detect_source_encoding(_string)
+          'US-ASCII'
+        end
+      end
+    end
+  end
+end