opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/matchers/matcher.rb

@@ -0,0 +1,301 @@
+require 'set'
+
+module RSpec
+  module Matchers
+    module DSL
+      # Contains the methods that are available from within the
+      # `RSpec::Matchers.define` DSL for creating custom matchers.
+      module Macros
+        # Stores the block that is used to determine whether this matcher passes
+        # or fails. The block should return a boolean value. When the matcher is
+        # passed to `expect(...).to` and the block returns `true`, then the expectation
+        # passes. Similarly, when the matcher is passed to `expect(...).not_to` and the
+        # block returns `false`, then the expectation passes.
+        #
+        # Use `match_for_should` when used in conjunction with
+        # `match_for_should_not`.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :be_even do
+        #       match do |actual|
+        #         actual.even?
+        #       end
+        #     end
+        #
+        #     expect(4).to be_even     # passes
+        #     expect(3).not_to be_even # passes
+        #     expect(3).to be_even     # fails
+        #     expect(4).not_to be_even # fails
+        #
+        # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
+        def match(&match_block)
+          define_user_override(:matches?, match_block) do |actual|
+            begin
+              @actual = actual
+              super(*actual_arg_for(match_block))
+            rescue RSpec::Expectations::ExpectationNotMetError
+              false
+            end
+          end
+        end
+        alias match_for_should match
+
+        # Use this to define the block for a negative expectation (`expect(...).not_to`)
+        # when the positive and negative forms require different handling. This
+        # is rarely necessary, but can be helpful, for example, when specifying
+        # asynchronous processes that require different timeouts.
+        #
+        # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
+        def match_for_should_not(&match_block)
+          define_user_override(:does_not_match?, match_block) do |actual|
+            @actual = actual
+            super(*actual_arg_for(match_block))
+          end
+        end
+
+        # Use this instead of `match` when the block will raise an exception
+        # rather than returning false to indicate a failure.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
+        #       match_unless_raises ValidationException do |validator|
+        #         validator.validate(candidate_address)
+        #       end
+        #     end
+        #
+        #     expect(email_validator).to accept_as_valid("person@company.com")
+        #
+        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+        def match_unless_raises(expected_exception=Exception, &match_block)
+          define_user_override(:matches?, match_block) do |actual|
+            @actual = actual
+            begin
+              super(*actual_arg_for(match_block))
+            rescue expected_exception => @rescued_exception
+              false
+            else
+              true
+            end
+          end
+        end
+
+        # Customizes the failure messsage to use when this matcher is
+        # asked to positively match. Only use this when the message
+        # generated by default doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { your_match_logic }
+        #
+        #       failure_message_for_should do |actual|
+        #         "Expected strength of #{expected}, but had #{actual.strength}"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+        def failure_message_for_should(&definition)
+          define_user_override(__method__, definition)
+        end
+
+        # Customize the failure messsage to use when this matcher is asked
+        # to negatively match. Only use this when the message generated by
+        # default doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { your_match_logic }
+        #
+        #       failure_message_for_should_not do |actual|
+        #         "Expected not to have strength of #{expected}, but did"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+        def failure_message_for_should_not(&definition)
+          define_user_override(__method__, definition)
+        end
+
+        # Customize the description to use for one-liners.  Only use this when
+        # the description generated by default doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :qualify_for do |expected|
+        #       match { your_match_logic }
+        #
+        #       description do
+        #         "qualify for #{expected}"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+        def description(&definition)
+          define_user_override(__method__, definition)
+        end
+
+        # Tells the matcher to diff the actual and expected values in the failure
+        # message.
+        def diffable
+          define_method(:diffable?) { true }
+        end
+
+        # Convenience for defining methods on this matcher to create a fluent
+        # interface. The trick about fluent interfaces is that each method must
+        # return self in order to chain methods together. `chain` handles that
+        # for you.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_errors_on do |key|
+        #       chain :with do |message|
+        #         @message = message
+        #       end
+        #
+        #       match do |actual|
+        #         actual.errors[key] == @message
+        #       end
+        #     end
+        #
+        #     expect(minor).to have_errors_on(:age).with("Not old enough to participate")
+        def chain(name, &definition)
+          define_user_override(name, definition) do |*args, &block|
+            super(*args, &block)
+            self
+          end
+        end
+
+      private
+
+        # Does the following:
+        #
+        # - Defines the named method usign a user-provided block
+        #   in @user_method_defs, which is included as an ancestor
+        #   in the singleton class in which we eval the `define` block.
+        # - Defines an overriden definition for the same method
+        #   usign the provided `our_def` block.
+        # - Provides a default `our_def` block for the common case
+        #   of needing to call the user's definition with `@actual`
+        #   as an arg, but only if their block's arity can handle it.
+        #
+        # This compiles the user block into an actual method, allowing
+        # them to use normal method constructs like `return`
+        # (e.g. for a early guard statement), while allowing us to define
+        # an override that can provide the wrapped handling
+        # (e.g. assigning `@actual`, rescueing errors, etc) and
+        # can `super` to the user's definition.
+        def define_user_override(method_name, user_def, &our_def)
+          @user_method_defs.__send__(:define_method, method_name, &user_def)
+          our_def ||= lambda { super(*actual_arg_for(user_def)) }
+          define_method(method_name, &our_def)
+        end
+      end
+
+      # Defines default implementations of the matcher
+      # protocol methods for custom matchers. You can
+      # override any of these using the {RSpec::Matchers::DSL::Macros Macros} methods
+      # from within an `RSpec::Matchers.define` block.
+      module DefaultImplementations
+        # @api private
+        # Used internally by objects returns by `should` and `should_not`.
+        def diffable?
+          false
+        end
+
+        # The default description.
+        def description
+          "#{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        # The default failure message for positive expectations.
+        def failure_message_for_should
+          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        # The default failure message for negative expectations.
+        def failure_message_for_should_not
+          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+      end
+
+      # The class used for custom matchers. The block passed to
+      # `RSpec::Matchers.define` will be evaluated in the context
+      # of the singleton class of an instance, and will have the
+      # {RSpec::Matchers::DSL::Macros Macros} methods available.
+      class Matcher
+        # Provides default implementations for the matcher protocol methods.
+        include DefaultImplementations
+
+        # Allows expectation expressions to be used in the match block.
+        include RSpec::Matchers
+
+        # Converts matcher name and expected args to an English expresion.
+        include RSpec::Matchers::Pretty
+
+        # Makes the macro methods available to an `RSpec::Matchers.define` block.
+        extend Macros
+
+        attr_reader   :expected, :actual, :rescued_exception
+        attr_accessor :matcher_execution_context
+
+        # @api private
+        def initialize(name, declarations, *expected)
+          @name     = name
+          @actual   = nil
+          @expected = expected
+
+          class << self
+            # See `Macros#define_user_override` above, for an explanation.
+            include(@user_method_defs = Module.new)
+            self
+          end.class_exec(*expected, &declarations)
+        end
+
+        # Adds the name (rather than a cryptic hex number)
+        # so we can identify an instance of
+        # the matcher in error messages (e.g. for `NoMethodError`)
+        def inspect
+          "#<#{self.class.name} #{name}>"
+        end
+
+        if RUBY_VERSION.to_f >= 1.9
+          # Indicates that this matcher responds to messages
+          # from the `matcher_execution_context` as well.
+          # Also, supports getting a method object for such methods.
+          def respond_to_missing?(method, include_private=false)
+            super || matcher_execution_context.respond_to?(method, include_private)
+          end
+        else # for 1.8.7
+          # Indicates that this matcher responds to messages
+          # from the `matcher_execution_context` as well.
+          def respond_to?(method, include_private=false)
+            super || matcher_execution_context.respond_to?(method, include_private)
+          end
+        end
+
+      private
+
+        def actual_arg_for(block)
+          block.arity.zero? ? [] : [@actual]
+        end
+
+        # Takes care of forwarding unhandled messages to the
+        # `matcher_execution_context` (typically the current
+        # running `RSpec::Core::Example`). This is needed by
+        # rspec-rails so that it can define matchers that wrap
+        # Rails' test helper methods, but it's also a useful
+        # feature in its own right.
+        def method_missing(method, *args, &block)
+          if matcher_execution_context.respond_to?(method)
+            matcher_execution_context.__send__ method, *args, &block
+          else
+            super(method, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/matchers/method_missing.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Matchers
+
+    private
+
+    def method_missing(method, *args, &block)
+      return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
+      return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/vendor_lib/rspec/matchers/operator_matcher.rb

@@ -0,0 +1,99 @@
+module RSpec
+  module Matchers
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def unregister(klass, operator)
+          registry[klass] && registry[klass].delete(operator)
+        end
+
+        def get(klass, operator)
+          klass.ancestors.each { |ancestor|
+            matcher = registry[ancestor] && registry[ancestor][operator]
+            return matcher if matcher
+          }
+
+          nil
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+              "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        RSpec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+
+    private
+
+      def uses_generic_implementation_of?(op)
+        Expectations.method_handle_for(@actual, op).owner == ::Kernel
+      rescue NameError
+        false
+      end
+
+      def eval_match(actual, operator, expected)
+        ::RSpec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+    end
+
+    module BuiltIn
+      class PositiveOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          if actual.__send__(operator, expected)
+            true
+          elsif ['==','===', '=~'].include?(operator)
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})")
+          else
+            fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          end
+        end
+      end
+
+      class NegativeOperatorMatcher < OperatorMatcher
+        def __delegate_operator(actual, operator, expected)
+          return false unless actual.__send__(operator, expected)
+          return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/matchers/pretty.rb

@@ -0,0 +1,70 @@
+module RSpec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words)
+        return "" unless words
+        words = Array(words).map { |w| to_word(w) }
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+
+      def to_word(item)
+        is_matcher_with_description?(item) ? item.description : item.inspect
+      end
+
+      def name_to_sentence
+        split_words(name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected) if defined?(@expected)
+      end
+
+      def name
+        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
+      end
+
+      # Borrowed from ActiveSupport
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      private
+
+      def is_matcher_with_description?(object)
+        RSpec::Matchers.is_a_matcher?(object) && object.respond_to?(:description)
+      end
+    end
+  end
+end

data/vendor_lib/rspec/matchers/test_unit_integration.rb

@@ -0,0 +1,11 @@
+# Include Matchers for other test frameworks.  Note that MiniTest _must_
+# come before TU because on ruby 1.9, T::U::TC is a subclass of MT::U::TC
+# and a 1.9 bug can lead to infinite recursion from the `super` call in our
+# method_missing hook.  See this gist for more info:
+# https://gist.github.com/845896
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
+end
+if defined?(Test::Unit::TestCase)
+  Test::Unit::TestCase.send(:include, RSpec::Matchers)
+end