opal-connect-rspec 0.5.0

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

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