opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,48 @@
+module RSpec
+  module Support
+    # Provides a means to fuzzy-match between two arbitrary objects.
+    # Understands array/hash nesting. Uses `===` or `==` to
+    # perform the matching.
+    module FuzzyMatcher
+      # @api private
+      def self.values_match?(expected, actual)
+        if 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
+
+        begin
+          expected === actual
+        rescue ArgumentError
+          # Some objects, like 0-arg lambdas on 1.9+, raise
+          # ArgumentError for `expected === actual`.
+          false
+        end
+      end
+
+      # @private
+      def self.arrays_match?(expected_list, actual_list)
+        return false if expected_list.size != actual_list.size
+
+        expected_list.zip(actual_list).all? do |expected, actual|
+          values_match?(expected, actual)
+        end
+      end
+
+      # @private
+      def self.hashes_match?(expected_hash, actual_hash)
+        return false if expected_hash.size != actual_hash.size
+
+        expected_hash.all? do |expected_key, expected_value|
+          actual_value = actual_hash.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+      end
+
+      private_class_method :arrays_match?, :hashes_match?
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+
+module RSpec
+  module Support
+    # @private
+    class HunkGenerator
+      def initialize(actual, expected)
+        @actual = actual
+        @expected = expected
+      end
+
+      def hunks
+        @file_length_difference = 0
+        @hunks ||= diffs.map do |piece|
+          build_hunk(piece)
+        end
+      end
+
+    private
+
+      def diffs
+        Diff::LCS.diff(expected_lines, actual_lines)
+      end
+
+      def expected_lines
+        @expected.split("\n").map! { |e| e.chomp }
+      end
+
+      def actual_lines
+        @actual.split("\n").map! { |e| e.chomp }
+      end
+
+      def build_hunk(piece)
+        Diff::LCS::Hunk.new(
+          expected_lines, actual_lines, piece, context_lines, @file_length_difference
+        ).tap do |h|
+          @file_length_difference = h.file_length_difference
+        end
+      end
+
+      def context_lines
+        3
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module RSpec
+  module Support
+    # @private
+    def self.matcher_definitions
+      @matcher_definitions ||= []
+    end
+
+    # Used internally to break cyclic dependency between mocks, expectations,
+    # and support. We don't currently have a consistent implementation of our
+    # matchers, though we are considering changing that:
+    # https://github.com/rspec/rspec-mocks/issues/513
+    #
+    # @private
+    def self.register_matcher_definition(&block)
+      matcher_definitions << block
+    end
+
+    # Remove a previously registered matcher. Useful for cleaning up after
+    # yourself in specs.
+    #
+    # @private
+    def self.deregister_matcher_definition(&block)
+      matcher_definitions.delete(block)
+    end
+
+    # @private
+    def self.is_a_matcher?(object)
+      matcher_definitions.any? { |md| md.call(object) }
+    end
+  end
+end

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

@@ -0,0 +1,272 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support "ruby_features"
+RSpec::Support.require_rspec_support "matcher_definition"
+
+module RSpec
+  module Support
+    # Extracts info about the number of arguments and allowed/required
+    # keyword args of a given method.
+    #
+    # @private
+    class MethodSignature
+      attr_reader :min_non_kw_args, :max_non_kw_args
+
+      def initialize(method)
+        @method = method
+        classify_parameters
+      end
+
+      def non_kw_args_arity_description
+        case max_non_kw_args
+        when min_non_kw_args then min_non_kw_args.to_s
+        when INFINITY then "#{min_non_kw_args} or more"
+        else "#{min_non_kw_args} to #{max_non_kw_args}"
+        end
+      end
+
+      def valid_non_kw_args?(positional_arg_count)
+        min_non_kw_args <= positional_arg_count &&
+          positional_arg_count <= max_non_kw_args
+      end
+
+      if RubyFeatures.optional_and_splat_args_supported?
+        def description
+          @description ||= begin
+            parts = []
+
+            unless non_kw_args_arity_description == "0"
+              parts << "arity of #{non_kw_args_arity_description}"
+            end
+
+            if @optional_kw_args.any?
+              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            if @required_kw_args.any?
+              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            parts << "any additional keyword args" if @allows_any_kw_args
+
+            parts.join(" and ")
+          end
+        end
+
+        def missing_kw_args_from(given_kw_args)
+          @required_kw_args - given_kw_args
+        end
+
+        def invalid_kw_args_from(given_kw_args)
+          return [] if @allows_any_kw_args
+          given_kw_args - @allowed_kw_args
+        end
+
+        def has_kw_args_in?(args)
+          Hash === args.last && could_contain_kw_args?(args)
+        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 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)|
+            case type
+            # def foo(a:)
+            when :keyreq  then @required_kw_args << name
+            # def foo(a: 1)
+            when :key     then @optional_kw_args << name
+            # def foo(**kw_args)
+            when :keyrest then @allows_any_kw_args = true
+            # def foo(a)
+            when :req     then @min_non_kw_args += 1
+            # def foo(a = 1)
+            when :opt     then optional_non_kw_args += 1
+            # def foo(*a)
+            when :rest    then optional_non_kw_args = INFINITY
+            end
+          end
+
+          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
+          @allowed_kw_args = @required_kw_args + @optional_kw_args
+        end
+      else
+        def description
+          "arity of #{non_kw_args_arity_description}"
+        end
+
+        def missing_kw_args_from(_given_kw_args)
+          []
+        end
+
+        def invalid_kw_args_from(_given_kw_args)
+          []
+        end
+
+        def has_kw_args_in?(_args)
+          false
+        end
+
+        def could_contain_kw_args?(*)
+          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
+        end
+      end
+
+      INFINITY = 1 / 0.0
+    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.
+    #
+    # However, we want to treat block args as required since you virtually
+    # always want to pass a value for each received argument and our
+    # `and_yield` has treated block args as required for many years.
+    #
+    # @api private
+    class BlockSignature < MethodSignature
+      if RubyFeatures.optional_and_splat_args_supported?
+        def classify_parameters
+          super
+          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
+        end
+      end
+    end
+
+    # Abstract base class for signature verifiers.
+    #
+    # @api private
+    class MethodSignatureVerifier
+      attr_reader :non_kw_args, :kw_args
+
+      def initialize(signature, args)
+        @signature = signature
+        @non_kw_args, @kw_args = split_args(*args)
+      end
+
+      def valid?
+        missing_kw_args.empty? &&
+          invalid_kw_args.empty? &&
+          valid_non_kw_args?
+      end
+
+      def error_message
+        if missing_kw_args.any?
+          "Missing required keyword arguments: %s" % [
+            missing_kw_args.join(", ")
+          ]
+        elsif invalid_kw_args.any?
+          "Invalid keyword arguments provided: %s" % [
+            invalid_kw_args.join(", ")
+          ]
+        elsif !valid_non_kw_args?
+          "Wrong number of arguments. Expected %s, got %s." % [
+            @signature.non_kw_args_arity_description,
+            non_kw_args.length
+          ]
+        end
+      end
+
+    private
+
+      def valid_non_kw_args?
+        @signature.valid_non_kw_args?(non_kw_args.length)
+      end
+
+      def missing_kw_args
+        @signature.missing_kw_args_from(kw_args)
+      end
+
+      def invalid_kw_args
+        @signature.invalid_kw_args_from(kw_args)
+      end
+
+      def split_args(*args)
+        kw_args = if @signature.has_kw_args_in?(args)
+                    args.pop.keys
+                  else
+                    []
+                  end
+
+        [args, kw_args]
+      end
+    end
+
+    # Figures out wether a given method can accept various arguments.
+    # Surprisingly non-trivial.
+    #
+    # @private
+    StrictSignatureVerifier = MethodSignatureVerifier
+
+    # Allows matchers to be used instead of providing keyword arguments. In
+    # practice, when this happens only the arity of the method is verified.
+    #
+    # @private
+    class LooseSignatureVerifier < MethodSignatureVerifier
+    private
+
+      def split_args(*args)
+        if RSpec::Support.is_a_matcher?(args.last) && @signature.could_contain_kw_args?(args)
+          args.pop
+          @signature = SignatureWithKeywordArgumentsMatcher.new(@signature)
+        end
+
+        super(*args)
+      end
+
+      # If a matcher is used in a signature in place of keyword arguments, all
+      # keyword argument validation needs to be skipped since the matcher is
+      # opaque.
+      #
+      # Instead, keyword arguments will be validated when the method is called
+      # and they are actually known.
+      #
+      # @private
+      class SignatureWithKeywordArgumentsMatcher
+        def initialize(signature)
+          @signature = signature
+        end
+
+        def missing_kw_args_from(_kw_args)
+          []
+        end
+
+        def invalid_kw_args_from(_kw_args)
+          []
+        end
+
+        def non_kw_args_arity_description
+          @signature.non_kw_args_arity_description
+        end
+
+        def valid_non_kw_args?(*args)
+          @signature.valid_non_kw_args?(*args)
+        end
+
+        def has_kw_args_in?(args)
+          @signature.has_kw_args_in?(args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different OS or OS features.
+    module OS
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+      end
+      module_function :windows?
+
+      def windows_file_path?
+        ::File::ALT_SEPARATOR == '\\'
+      end
+      module_function :windows_file_path?
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module RSpec
+  module Support
+    # Provides recursive constant lookup methods useful for
+    # constant stubbing.
+    module RecursiveConstMethods
+      # We only want to consider constants that are defined directly on a
+      # particular module, and not include top-level/inherited constants.
+      # Unfortunately, the constant API changed between 1.8 and 1.9, so
+      # we need to conditionally define methods to ignore the top-level/inherited
+      # constants.
+      #
+      # Given:
+      #   class A; B = 1; end
+      #   class C < A; end
+      #
+      # On 1.8:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => false
+      #   - C.constants # => ["B"]
+      #   - None of these methods accept the extra `inherit` argument
+      # On 1.9:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => true
+      #   - C.const_get("Hash", false) # => raises NameError
+      #   - C.const_defined?("Hash", false) # => false
+      #   - C.constants # => [:B]
+      #   - C.constants(false) #=> []
+      if Module.method(:const_defined?).arity == 1
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
+
+          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
+        end
+
+        def constants_defined_on(mod)
+          mod.constants.select { |c| const_defined_on?(mod, c) }
+        end
+      else
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name, false)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          mod.const_get(const_name, false)
+        end
+
+        def constants_defined_on(mod)
+          mod.constants(false)
+        end
+      end
+
+      def recursive_const_get(const_name)
+        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
+          get_const_defined_on(mod, name)
+        end
+      end
+
+      def recursive_const_defined?(const_name)
+        parts = normalize_const_name(const_name).split('::')
+        parts.inject([Object, '']) do |(mod, full_name), name|
+          yield(full_name, name) if block_given? && !(Module === mod)
+          return false unless const_defined_on?(mod, name)
+          [get_const_defined_on(mod, name), [mod, name].join('::')]
+        end
+      end
+
+      def normalize_const_name(const_name)
+        const_name.sub(/\A::/, '')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different rubies
+    module Ruby
+      def jruby?
+        RUBY_PLATFORM == 'java'
+      end
+      module_function :jruby?
+    end
+
+    # @api private
+    #
+    # Provides query methods for ruby features that differ among
+    # implementations.
+    module RubyFeatures
+      def optional_and_splat_args_supported?
+        Method.method_defined?(:parameters)
+      end
+      module_function :optional_and_splat_args_supported?
+
+      def kw_args_supported?
+        RUBY_VERSION >= '2.0.0' && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :kw_args_supported?
+
+      def required_kw_args_supported?
+        RUBY_VERSION >= '2.1.0' && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :required_kw_args_supported?
+
+      def module_prepends_supported?
+        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
+      end
+      module_function :module_prepends_supported?
+
+      def supports_rebinding_module_methods?
+        # RBX and JRuby don't yet support this.
+        RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :supports_rebinding_module_methods?
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module RSpecHelpers
+  def expect_no_deprecation
+    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+  end
+
+  def expect_deprecation_with_call_site(file, line, snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      expect(options[:call_site]).to include([file, line].join(':'))
+      expect(options[:deprecated]).to match(snippet)
+    end
+  end
+
+  def expect_deprecation_without_call_site(snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      expect(options[:call_site]).to eq nil
+      expect(options[:deprecated]).to match(snippet)
+    end
+  end
+
+  def expect_warn_deprecation_with_call_site(file, line, snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      message = options[:message]
+      expect(message).to match(snippet)
+      expect(message).to include([file, line].join(':'))
+    end
+  end
+
+  def expect_warn_deprecation(snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      message = options[:message]
+      expect(message).to match(snippet)
+    end
+  end
+
+  def allow_deprecation
+    allow(RSpec.configuration.reporter).to receive(:deprecation)
+  end
+
+  def expect_no_deprecations
+    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+  end
+
+  def expect_warning_without_call_site(expected=//)
+    expect(::Kernel).to receive(:warn) do |message|
+      expect(message).to match expected
+      expect(message).to_not match(/Called from/)
+    end
+  end
+
+  def expect_warning_with_call_site(file, line, expected=//)
+    expect(::Kernel).to receive(:warn) do |message|
+      expect(message).to match expected
+      expect(message).to match(/Called from #{file}:#{line}/)
+    end
+  end
+
+  def allow_warning
+    allow(::Kernel).to receive(:warn)
+  end
+end

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

@@ -0,0 +1,9 @@
+module RSpec
+  module Support
+    module FormattingSupport
+      def dedent(string)
+        string.gsub(/^\s+\|/, '').chomp
+      end
+    end
+  end
+end

data/{vendor_lib → rspec-support/lib}/rspec/support/spec/in_sub_process.rb

@@ -3,6 +3,8 @@ module RSpec
     module InSubProcess
       if Process.respond_to?(:fork) && !(RUBY_PLATFORM == 'java' && RUBY_VERSION == '1.8.7')
         # Useful as a way to isolate a global change to a subprocess.
+
+        # rubocop:disable MethodLength
         def in_sub_process
           readme, writeme = IO.pipe
 
@@ -31,10 +33,11 @@ module RSpec
         end
       else
         def in_sub_process
-          pending "This spec requires forking to work properly, " +
-                  "and your platform does not support forking"
+          skip "This spec requires forking to work properly, " \
+               "and your platform does not support forking"
         end
       end
+      # rubocop:enable MethodLength
     end
   end
 end

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

@@ -0,0 +1,44 @@
+require 'rspec/support/spec/shell_out'
+
+module RSpec
+  module Support
+    module WarningsPrevention
+      def files_to_require_for(lib)
+        slash         = File::SEPARATOR
+        lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
+        load_path     = $LOAD_PATH.grep(lib_path_re).first
+        files         = Dir["#{load_path}/**/*.rb"]
+        extract_regex = /#{Regexp.escape(load_path) + File::SEPARATOR}(.+)\.rb$/
+
+        # We sort to ensure the files are loaded in a consistent order, regardless
+        # of OS. Otherwise, it could load in a different order on Travis than
+        # locally, and potentially trigger a "circular require considered harmful"
+        # warning or similar.
+        files.sort.map { |file| file[extract_regex, 1] }
+      end
+    end
+  end
+end
+
+RSpec.shared_examples_for "a library that issues no warnings when loaded" do |lib, *preamble_stmnts|
+  include RSpec::Support::ShellOut
+  include RSpec::Support::WarningsPrevention
+
+  it "issues no warnings when loaded", :slow do
+    # We want to explicitly load every file because each lib has some files that
+    # aren't automatically loaded, instead being delayed based on an autoload
+    # (such as for rspec-expectations' matchers) or based on a config option
+    # (e.g. `config.mock_with :rr` => 'rspec/core/mocking_adapters/rr').
+    statements = preamble_stmnts + files_to_require_for(lib).map do |file|
+      "require '#{file}'"
+    end
+
+    command = statements.join("; ")
+
+    stdout, stderr, status = run_ruby_with_current_load_path(command, "-w")
+
+    expect(stdout).to eq("")
+    expect(stderr).to eq("")
+    expect(status.exitstatus).to eq(0)
+  end
+end