opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/matchers/built_in/match_array.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class MatchArray < BaseMatcher
-        def match(expected, actual)
-          return false unless actual.respond_to? :to_ary
-          @extra_items = difference_between_arrays(actual, expected)
-          @missing_items = difference_between_arrays(expected, actual)
-          @extra_items.empty? & @missing_items.empty?
-        end
-
-        def failure_message_for_should
-          if actual.respond_to? :to_ary
-            message =  "expected collection contained:  #{safe_sort(expected).inspect}\n"
-            message += "actual collection contained:    #{safe_sort(actual).inspect}\n"
-            message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
-            message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
-          else
-            message = "expected an array, actual collection was #{actual.inspect}"
-          end
-
-          message
-        end
-
-        def failure_message_for_should_not
-          "Matcher does not support should_not"
-        end
-
-        def description
-          "contain exactly #{_pretty_print(expected)}"
-        end
-
-        private
-
-        def safe_sort(array)
-          array.sort rescue array
-        end
-
-        def difference_between_arrays(array_1, array_2)
-          difference = array_1.to_ary.dup
-          array_2.to_ary.each do |element|
-            if index = difference.index(element)
-              difference.delete_at(index)
-            end
-          end
-          difference
-        end
-      end
-    end
-  end
-end

data/vendor_lib/rspec/matchers/built_in/start_and_end_with.rb

@@ -1,48 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class StartAndEndWith < BaseMatcher
-        def initialize(*expected)
-          @expected = expected.length == 1 ? expected.first : expected
-        end
-
-        def matches?(actual)
-          @actual = actual.respond_to?(:[]) ? actual : (raise ArgumentError.new("#{actual.inspect} does not respond to :[]"))
-          begin
-            @expected.respond_to?(:length) ? subset_matches?(@expected, @actual) : element_matches?(@expected, @actual)
-          rescue ArgumentError
-            raise ArgumentError.new("#{actual.inspect} does not have ordered elements")
-          end
-        end
-
-        def failure_message_for_should
-          "expected #{@actual.inspect} to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected #{@actual.inspect} not to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
-        end
-      end
-
-      class StartWith < StartAndEndWith
-        def subset_matches?(expected, actual)
-          actual[0, expected.length] == expected
-        end
-
-        def element_matches?(expected, actual)
-          @actual[0] == @expected
-        end
-      end
-
-      class EndWith < StartAndEndWith
-        def subset_matches?(expected, actual)
-          actual[-expected.length, expected.length] == expected
-        end
-
-        def element_matches?(expected, actual)
-          actual[-1] == expected
-        end
-      end
-    end
-  end
-end

data/vendor_lib/rspec/matchers/built_in/yield.rb

@@ -1,297 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class YieldProbe
-        def self.probe(block)
-          probe = new
-          assert_valid_expect_block!(block)
-          block.call(probe)
-          probe.assert_used!
-          probe
-        end
-
-        attr_accessor :num_yields, :yielded_args
-
-        def initialize
-          @used = false
-          self.num_yields, self.yielded_args = 0, []
-        end
-
-        def to_proc
-          @used = true
-
-          probe = self
-          Proc.new do |*args|
-            probe.num_yields += 1
-            probe.yielded_args << args
-            nil # to indicate the block does not return a meaningful value
-          end
-        end
-
-        def single_yield_args
-          yielded_args.first
-        end
-
-        def yielded_once?(matcher_name)
-          case num_yields
-          when 1 then true
-          when 0 then false
-          else
-            raise "The #{matcher_name} matcher is not designed to be used with a " +
-                  "method that yields multiple times. Use the yield_successive_args " +
-                  "matcher for that case."
-          end
-        end
-
-        def successive_yield_args
-          yielded_args.map do |arg_array|
-            arg_array.size == 1 ? arg_array.first : arg_array
-          end
-        end
-
-        def assert_used!
-          return if @used
-          raise "You must pass the argument yielded to your expect block on " +
-                "to the method-under-test as a block. It acts as a probe that " +
-                "allows the matcher to detect whether or not the method-under-test " +
-                "yields, and, if so, how many times, and what the yielded arguments " +
-                "are."
-        end
-
-        def self.assert_valid_expect_block!(block)
-          return if block.arity == 1
-          raise "Your expect block must accept an argument to be used with this " +
-                "matcher. Pass the argument as a block on to the method you are testing."
-        end
-      end
-
-      class YieldControl < BaseMatcher
-        def initialize
-          @expectation_type = nil
-          @expected_yields_count = nil
-        end
-
-        def matches?(block)
-          probe = YieldProbe.probe(block)
-
-          if @expectation_type
-            probe.num_yields.send(@expectation_type, @expected_yields_count)
-          else
-            probe.yielded_once?(:yield_control)
-          end
-        end
-
-        def once
-          exactly(1)
-          self
-        end
-
-        def twice
-          exactly(2)
-          self
-        end
-
-        def exactly(number)
-          set_expected_yields_count(:==, number)
-          self
-        end
-
-        def at_most(number)
-          set_expected_yields_count(:<=, number)
-          self
-        end
-
-        def at_least(number)
-          set_expected_yields_count(:>=, number)
-          self
-        end
-
-        def times
-          self
-        end
-
-        def failure_message_for_should
-          'expected given block to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
-          end
-        end
-
-        def failure_message_for_should_not
-          'expected given block not to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
-          end
-        end
-
-        private
-
-        def set_expected_yields_count(relativity, n)
-          @expectation_type = relativity
-          @expected_yields_count = case n
-                                   when Numeric then n
-                                   when :once then 1
-                                   when :twice then 2
-                                   end
-        end
-
-        def relativity_failure_message
-          return '' unless @expected_yields_count
-          " #{human_readable_expecation_type}#{human_readable_count}"
-        end
-
-        def human_readable_expecation_type
-          case @expectation_type
-          when :<= then 'at most '
-          when :>= then 'at least '
-          else ''
-          end
-        end
-
-        def human_readable_count
-          case @expected_yields_count
-          when 1 then "once"
-          when 2 then "twice"
-          else "#{@expected_yields_count} times"
-          end
-        end
-      end
-
-      class YieldWithNoArgs < BaseMatcher
-
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
-        end
-
-        def failure_message_for_should
-          "expected given block to yield with no arguments, but #{failure_reason}"
-        end
-
-        def failure_message_for_should_not
-          "expected given block not to yield with no arguments, but did"
-        end
-
-      private
-
-        def failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            "yielded with arguments: #{@probe.single_yield_args.inspect}"
-          end
-        end
-      end
-
-      class YieldWithArgs
-        def initialize(*args)
-          @expected = args
-        end
-
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @actual = @probe.single_yield_args
-          @probe.yielded_once?(:yield_with_args) && args_match?
-        end
-        alias == matches?
-
-        def failure_message_for_should
-          "expected given block to yield with arguments, but #{positive_failure_reason}"
-        end
-
-        def failure_message_for_should_not
-          "expected given block not to yield with arguments, but #{negative_failure_reason}"
-        end
-
-        def description
-          desc = "yield with args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" unless @expected.empty?
-          desc
-        end
-
-      private
-
-        def positive_failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            @positive_args_failure
-          end
-        end
-
-        def negative_failure_reason
-          if all_args_match?
-            "yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
-          else
-            "did"
-          end
-        end
-
-        def args_match?
-          if @expected.empty? # expect {...}.to yield_with_args
-            @positive_args_failure = "yielded with no arguments" if @actual.empty?
-            return !@actual.empty?
-          end
-
-          unless match = all_args_match?
-            @positive_args_failure = "yielded with unexpected arguments" +
-              "\nexpected: #{@expected.inspect}" +
-              "\n     got: #{@actual.inspect} (compared using === and ==)"
-          end
-
-          match
-        end
-
-        def all_args_match?
-          return false if @expected.size != @actual.size
-
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
-        end
-      end
-
-      class YieldSuccessiveArgs
-        def initialize(*args)
-          @expected = args
-        end
-
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @actual = @probe.successive_yield_args
-          args_match?
-        end
-        alias == matches?
-
-        def failure_message_for_should
-          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
-            "\nexpected: #{@expected.inspect}" +
-            "\n     got: #{@actual.inspect} (compared using === and ==)"
-        end
-
-        def failure_message_for_should_not
-          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
-        end
-
-        def description
-          desc = "yield successive args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
-          desc
-        end
-
-      private
-
-        def args_match?
-          return false if @expected.size != @actual.size
-
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
-        end
-      end
-    end
-  end
-end
-

data/vendor_lib/rspec/matchers/built_in.rb

@@ -1,39 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      require 'rspec/matchers/built_in/base_matcher'
-      autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
-      autoload :Be,             'rspec/matchers/built_in/be'
-      autoload :BeTruthy,         'rspec/matchers/built_in/be'
-      autoload :BeFalsey,        'rspec/matchers/built_in/be'
-      autoload :BeNil,          'rspec/matchers/built_in/be'
-      autoload :BeComparedTo,   'rspec/matchers/built_in/be'
-      autoload :BePredicate,    'rspec/matchers/built_in/be'
-      autoload :BeAKindOf,      'rspec/matchers/built_in/be_kind_of'
-      autoload :BeWithin,       'rspec/matchers/built_in/be_within'
-      autoload :Change,         'rspec/matchers/built_in/change'
-      autoload :Cover,          'rspec/matchers/built_in/cover' if (1..2).respond_to?(:cover?)
-      autoload :Eq,             'rspec/matchers/built_in/eq'
-      autoload :Eql,            'rspec/matchers/built_in/eql'
-      autoload :Equal,          'rspec/matchers/built_in/equal'
-      autoload :Exist,          'rspec/matchers/built_in/exist'
-      autoload :Has,            'rspec/matchers/built_in/has'
-      autoload :Have,           'rspec/matchers/built_in/have'
-      autoload :Include,        'rspec/matchers/built_in/include'
-      autoload :Match,          'rspec/matchers/built_in/match'
-      autoload :MatchArray,     'rspec/matchers/built_in/match_array'
-      autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
-      autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
-      autoload :StartWith,      'rspec/matchers/built_in/start_and_end_with'
-      autoload :EndWith,        'rspec/matchers/built_in/start_and_end_with'
-      autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
-      autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
-      autoload :YieldControl,   'rspec/matchers/built_in/yield'
-      autoload :YieldWithArgs,  'rspec/matchers/built_in/yield'
-      autoload :YieldWithNoArgs, 'rspec/matchers/built_in/yield'
-      autoload :YieldSuccessiveArgs, 'rspec/matchers/built_in/yield'
-    end
-  end
-end
-
-

data/vendor_lib/rspec/matchers/compatibility.rb

@@ -1,14 +0,0 @@
-RSpec::Matchers.constants.each do |c|
-  if Class === (klass = RSpec::Matchers.const_get(c))
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
-      klass.class_exec do
-        alias_method :failure_message, :failure_message_for_should
-      end
-    end
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
-      klass.class_exec do
-        alias_method :negative_failure_message, :failure_message_for_should_not
-      end
-    end
-  end
-end

data/vendor_lib/rspec/matchers/dsl.rb

@@ -1,23 +0,0 @@
-module RSpec
-  module Matchers
-    module DSL
-      # Defines a custom matcher.
-      # @see RSpec::Matchers
-      def define(name, &declarations)
-        define_method name do |*expected|
-          matcher = RSpec::Matchers::DSL::Matcher.new(name, declarations, *expected)
-          matcher.matcher_execution_context = @matcher_execution_context ||= self
-          matcher
-        end
-      end
-
-      alias_method :matcher, :define
-
-      if RSpec.respond_to?(:configure)
-        RSpec.configure {|c| c.extend self}
-      end
-    end
-  end
-end
-
-RSpec::Matchers.extend RSpec::Matchers::DSL

data/vendor_lib/rspec/matchers/method_missing.rb

@@ -1,12 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,11 +0,0 @@
-# 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