opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/expectations/differ.rb

@@ -1,154 +0,0 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'pp'
-
-module RSpec
-  module Expectations
-    class Differ
-
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(input_data_new, input_data_old)
-        encoding = pick_encoding input_data_new, input_data_old
-        output = matching_encoding("", encoding)
-        data_old = input_data_old.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        data_new = input_data_new.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(
-              data_old, data_new, piece, context_lines, file_length_difference
-            )
-            file_length_difference = hunk.file_length_difference
-            next unless oldhunk
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              if hunk.respond_to?(:merge)
-                # diff-lcs 1.2.x
-                hunk.merge(oldhunk)
-              else
-                # diff-lcs 1.1.3
-                hunk.unshift(oldhunk)
-              end
-            else
-              output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-            end
-          ensure
-            oldhunk = hunk
-            output << matching_encoding("\n", encoding)
-          end
-        end
-        #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-        output << matching_encoding("\n", encoding)
-        color_diff output
-      rescue Encoding::CompatibilityError
-        if input_data_new.encoding != input_data_old.encoding
-          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
-          "differs from the encoding of the expected string (#{input_data_new.encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
-        end
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        if diff = diff_as_string(actual_as_string, expected_as_string)
-          color_diff diff
-        end
-      end
-
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      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 color_diff(diff)
-        return diff unless RSpec::Matchers.configuration.color?
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : line
-          else
-            line
-          end
-        }.join
-      end
-
-      def object_to_string(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], "")
-
-            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
-            #
-            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
-            # <# a: b: c:> not <# c: a: b:>
-            encoding = pick_encoding pp_key, pp_value
-            matching_encoding("#{pp_key} => #{pp_value}", encoding)
-          end.join(",\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
-        end
-      end
-
-    private
-
-      if String.method_defined?(:encoding)
-        def pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-
-        def matching_encoding(string, encoding)
-          string.encode encoding
-        rescue Encoding::UndefinedConversionError
-          string.encode(encoding, :undef => :replace)
-        end
-      else
-        def pick_encoding(source_a, source_b)
-        end
-
-        def matching_encoding(string, encoding)
-          string
-        end
-      end
-    end
-
-  end
-end
-

data/vendor_lib/rspec/expectations/errors.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Expectations
-    if defined?(Test::Unit::AssertionFailedError)
-      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
-    else
-      class ExpectationNotMetError < ::StandardError; end
-    end
-  end
-end

data/vendor_lib/rspec/expectations/expectation_target.rb

@@ -1,87 +0,0 @@
-module RSpec
-  module Expectations
-    # Wraps the target of an expectation.
-    # @example
-    #   expect(something) # => ExpectationTarget wrapping something
-    #
-    #   # used with `to`
-    #   expect(actual).to eq(3)
-    #
-    #   # with `not_to`
-    #   expect(actual).not_to eq(3)
-    class ExpectationTarget
-      class << self
-        attr_accessor :deprecated_should_enabled
-        alias deprecated_should_enabled? deprecated_should_enabled
-      end
-
-      # @api private
-      def initialize(target)
-        @target = target
-      end
-
-      # Runs the given expectation, passing if `matcher` returns true.
-      # @example
-      #   expect(value).to eq(5)
-      #   expect { perform }.to raise_error
-      # @param [Matcher]
-      #   matcher
-      # @param [String or Proc] message optional message to display when the expectation fails
-      # @return [Boolean] true if the expectation succeeds (else raises)
-      # @see RSpec::Matchers
-      def to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to, matcher)
-        RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
-      end
-
-      # Runs the given expectation, passing if `matcher` returns false.
-      # @example
-      #   expect(value).not_to eq(5)
-      # @param [Matcher]
-      #   matcher
-      # @param [String or Proc] message optional message to display when the expectation fails
-      # @return [Boolean] false if the negative expectation succeeds (else raises)
-      # @see RSpec::Matchers
-      def not_to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:not_to, matcher)
-        RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
-      end
-      alias to_not not_to
-
-      def self.enable_deprecated_should
-        return if deprecated_should_enabled?
-
-        def should(*args)
-          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
-          @target.should(*args)
-        end
-
-        def should_not(*args)
-          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
-          @target.should_not(*args)
-        end
-
-        self.deprecated_should_enabled = true
-      end
-
-      def self.disable_deprecated_should
-        return unless deprecated_should_enabled?
-
-        remove_method :should
-        remove_method :should_not
-
-        self.deprecated_should_enabled = false
-      end
-
-    private
-
-      def prevent_operator_matchers(verb, matcher)
-        return if matcher
-
-        raise ArgumentError, "The expect syntax does not support operator matchers, " +
-                             "so you must pass a matcher to `##{verb}`."
-      end
-    end
-  end
-end
-

data/vendor_lib/rspec/expectations/extensions/object.rb

@@ -1,29 +0,0 @@
-module RSpec
-  module Expectations
-    module DeprecatedConstants
-      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
-      # delegates to super.
-      def const_missing(name)
-        case name
-        when :Rspec, :Spec
-          RSpec.deprecate(name.to_s, :replacement => "RSpec")
-          RSpec
-        else
-          begin
-            super
-          rescue Exception => e
-            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
-            raise e
-          end
-        end
-      end
-    end
-
-    # @deprecated (no replacement)
-    def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
-    end
-  end
-end
-
-extend RSpec::Expectations::DeprecatedConstants

data/vendor_lib/rspec/expectations/extensions.rb

@@ -1 +0,0 @@
-require 'rspec/expectations/extensions/object'

data/vendor_lib/rspec/expectations/fail_with.rb

@@ -1,79 +0,0 @@
-module RSpec
-  module Expectations
-    class << self
-      # @private
-      def differ
-        @differ ||= Differ.new
-      end
-
-      # Raises an RSpec::Expectations::ExpectationNotMetError with message.
-      # @param [String] message
-      # @param [Object] expected
-      # @param [Object] actual
-      #
-      # Adds a diff to the failure message when `expected` and `actual` are
-      # both present.
-      def fail_with(message, expected=nil, actual=nil)
-        if !message
-          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
-                               "appropriate failure_message_for_* method to return a string?"
-        end
-
-        if actual && expected
-          if all_strings?(actual, expected)
-            if any_multiline_strings?(actual, expected)
-              message << "\nDiff:" << differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
-            end
-          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            message << "\nDiff:" << differ.diff_as_object(actual, expected)
-          end
-        end
-
-        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
-      end
-
-    private
-
-      def no_procs?(*args)
-        args.flatten.none? {|a| Proc === a}
-      end
-
-      def all_strings?(*args)
-        args.flatten.all? {|a| String === a}
-      end
-
-      def any_multiline_strings?(*args)
-        all_strings?(*args) && args.flatten.any? { |a| multiline?(a) }
-      end
-
-      def no_numbers?(*args)
-        args.flatten.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
-    end
-  end
-end

data/vendor_lib/rspec/expectations/handler.rb

@@ -1,68 +0,0 @@
-module RSpec
-  module Expectations
-
-    class ExpectationHandler
-      def self.check_message(msg)
-        unless msg.nil? || msg.respond_to?(:to_str) || msg.respond_to?(:call)
-          ::Kernel.warn [
-            "WARNING: ignoring the provided expectation message argument (",
-            msg.inspect,
-            ") since it is not a string or a proc."
-          ].join
-        end
-      end
-    end
-
-    class PositiveExpectationHandler < ExpectationHandler
-
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        check_message(message)
-        ::RSpec::Matchers.last_should = :should
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.matches?(actual, &block)
-        return match if match
-
-        message = message.call if message.respond_to?(:call)
-
-        message ||= matcher.respond_to?(:failure_message_for_should) ?
-                    matcher.failure_message_for_should :
-                    matcher.failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-
-    class NegativeExpectationHandler < ExpectationHandler
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        check_message(message)
-        ::RSpec::Matchers.last_should = :should_not
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.respond_to?(:does_not_match?) ?
-                !matcher.does_not_match?(actual, &block) :
-                matcher.matches?(actual, &block)
-        return match unless match
-
-        message = message.call if message.respond_to?(:call)
-
-        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
-                    matcher.failure_message_for_should_not :
-                    matcher.negative_failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-  end
-end
-

data/vendor_lib/rspec/expectations/syntax.rb

@@ -1,182 +0,0 @@
-module RSpec
-  module Expectations
-    # @api private
-    # Provides methods for enabling and disabling the available
-    # syntaxes provided by rspec-expectations.
-    module Syntax
-      extend self
-
-      # @method should
-      # Passes if `matcher` returns true.  Available on every `Object`.
-      # @example
-      #   actual.should eq expected
-      #   actual.should match /expression/
-      # @param [Matcher]
-      #   matcher
-      # @param [String] message optional message to display when the expectation fails
-      # @return [Boolean] true if the expectation succeeds (else raises)
-      # @see RSpec::Matchers
-
-      # @method should_not
-      # Passes if `matcher` returns false.  Available on every `Object`.
-      # @example
-      #   actual.should_not eq expected
-      # @param [Matcher]
-      #   matcher
-      # @param [String] message optional message to display when the expectation fails
-      # @return [Boolean] false if the negative expectation succeeds (else raises)
-      # @see RSpec::Matchers
-
-      # @method expect
-      # Supports `expect(actual).to matcher` syntax by wrapping `actual` in an
-      # `ExpectationTarget`.
-      # @example
-      #   expect(actual).to eq(expected)
-      #   expect(actual).not_to eq(expected)
-      # @return [ExpectationTarget]
-      # @see ExpectationTarget#to
-      # @see ExpectationTarget#not_to
-
-      # @api private
-      # Determines where we add `should` and `should_not`.
-      def default_should_host
-        @default_should_host ||= ::Object.ancestors.last
-      end
-
-      def self.warn_about_should!
-        @warn_about_should = true
-      end
-
-      def self.warn_about_should_unless_configured(method_name)
-        if @warn_about_should
-          RSpec.deprecate(
-            "Using `#{method_name}` from rspec-expectations' old `:should` syntax without explicitly enabling the syntax",
-            :replacement => "the new `:expect` syntax or explicitly enable `:should`"
-          )
-
-          @warn_about_should = false
-        end
-      end
-
-      # @api private
-      # Enables the `should` syntax.
-      def enable_should(syntax_host = default_should_host)
-        @warn_about_should = false
-        return if should_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          def should(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
-            ::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
-          end
-
-          def should_not(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
-            ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
-          end
-        end
-
-        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if expect_enabled?
-      end
-
-      # @api private
-      # Disables the `should` syntax.
-      def disable_should(syntax_host = default_should_host)
-        return unless should_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          undef should
-          undef should_not
-        end
-
-        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
-      end
-
-      # @api private
-      # Enables the `expect` syntax.
-      def enable_expect(syntax_host = ::RSpec::Matchers)
-        return if expect_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          def expect(*target, &target_block)
-            target << target_block if block_given?
-            raise ArgumentError.new("You must pass an argument or a block to #expect but not both.") unless target.size == 1
-            ::RSpec::Expectations::ExpectationTarget.new(target.first)
-          end
-        end
-
-        ::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if should_enabled?
-      end
-
-      # @api private
-      # Disables the `expect` syntax.
-      def disable_expect(syntax_host = ::RSpec::Matchers)
-        return unless expect_enabled?(syntax_host)
-
-        syntax_host.module_exec do
-          undef expect
-        end
-
-        ::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
-      end
-
-      # @api private
-      # Indicates whether or not the `should` syntax is enabled.
-      def should_enabled?(syntax_host = default_should_host)
-        syntax_host.method_defined?(:should)
-      end
-
-      # @api private
-      # Indicates whether or not the `expect` syntax is enabled.
-      def expect_enabled?(syntax_host = ::RSpec::Matchers)
-        syntax_host.method_defined?(:expect)
-      end
-
-      # @api private
-      # Generates a positive expectation expression.
-      def positive_expression(target_expression, matcher_expression)
-        expression_generator.positive_expression(target_expression, matcher_expression)
-      end
-
-      # @api private
-      # Generates a negative expectation expression.
-      def negative_expression(target_expression, matcher_expression)
-        expression_generator.negative_expression(target_expression, matcher_expression)
-      end
-
-      # @api private
-      # Selects which expression generator to use based on the configured syntax.
-      def expression_generator
-        if expect_enabled?
-          ExpectExpressionGenerator
-        else
-          ShouldExpressionGenerator
-        end
-      end
-
-      # @api private
-      # Generates expectation expressions for the `should` syntax.
-      module ShouldExpressionGenerator
-        def self.positive_expression(target_expression, matcher_expression)
-          "#{target_expression}.should #{matcher_expression}"
-        end
-
-        def self.negative_expression(target_expression, matcher_expression)
-          "#{target_expression}.should_not #{matcher_expression}"
-        end
-      end
-
-      # @api private
-      # Generates expectation expressions for the `expect` syntax.
-      module ExpectExpressionGenerator
-        def self.positive_expression(target_expression, matcher_expression)
-          "expect(#{target_expression}).to #{matcher_expression}"
-        end
-
-        def self.negative_expression(target_expression, matcher_expression)
-          "expect(#{target_expression}).not_to #{matcher_expression}"
-        end
-      end
-    end
-  end
-end

data/vendor_lib/rspec/expectations.rb

@@ -1,75 +0,0 @@
-require 'rspec/support/caller_filter'
-require 'rspec/support/warnings'
-
-require 'rspec/expectations/extensions'
-require 'rspec/matchers'
-require 'rspec/expectations/expectation_target'
-require 'rspec/matchers/configuration'
-require 'rspec/expectations/fail_with'
-require 'rspec/expectations/errors'
-require 'rspec/expectations/handler'
-require 'rspec/expectations/version'
-require 'rspec/expectations/differ'
-
-module RSpec
-  # RSpec::Expectations adds two instance methods to every object:
-  #
-  #     should(matcher=nil)
-  #     should_not(matcher=nil)
-  #
-  # Both methods take an optional matcher object (See
-  # [RSpec::Matchers](../RSpec/Matchers)).  When `should` is invoked with a
-  # matcher, it turns around and calls `matcher.matches?(self)`.  For example,
-  # in the expression:
-  #
-  #     order.total.should eq(Money.new(5.55, :USD))
-  #
-  # the `should` method invokes the equivalent of `eq.matches?(order.total)`. If
-  # `matches?` returns true, the expectation is met and execution continues. If
-  # `false`, then the spec fails with the message returned by
-  # `eq.failure_message_for_should`.
-  #
-  # Given the expression:
-  #
-  #     order.entries.should_not include(entry)
-  #
-  # the `should_not` method invokes the equivalent of
-  # `include.matches?(order.entries)`, but it interprets `false` as success, and
-  # `true` as a failure, using the message generated by
-  # `eq.failure_message_for_should_not`.
-  #
-  # rspec-expectations ships with a standard set of useful matchers, and writing
-  # your own matchers is quite simple.
-  #
-  # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
-  # built-in matchers that ship with rspec-expectations, and how to write your
-  # own custom matchers.
-  module Expectations
-
-    # @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)
-    if RUBY_VERSION.to_i >= 2
-      def self.method_handle_for(object, method_name)
-        KERNEL_METHOD_METHOD.bind(object).call(method_name)
-      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
-      end
-    end
-  end
-end