opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -1,68 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      #
-      # Used _internally_ as a base class for matchers that ship with
-      # rspec-expectations.
-      #
-      # ### Warning:
-      #
-      # This class is for internal use, and subject to change without notice.  We
-      # strongly recommend that you do not base your custom matchers on this
-      # class. If/when this changes, we will announce it and remove this warning.
-      class BaseMatcher
-        include RSpec::Matchers::Pretty
-
-        attr_reader :actual, :expected, :rescued_exception
-
-        def initialize(expected = nil)
-          @expected = expected
-        end
-
-        def matches?(actual)
-          @actual = actual
-          match(expected, actual)
-        end
-
-        def match_unless_raises(*exceptions)
-          exceptions.unshift Exception if exceptions.empty?
-          begin
-            yield
-            true
-          rescue *exceptions => @rescued_exception
-            false
-          end
-        end
-
-        def failure_message_for_should
-          assert_ivars :@actual, :@expected
-          "expected #{@actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        def failure_message_for_should_not
-          assert_ivars :@actual, :@expected
-          "expected #{@actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        def description
-          expected ? "#{name_to_sentence} #{@expected.inspect}" : name_to_sentence
-        end
-
-        def diffable?
-          false
-        end
-
-        def ==(other)
-          matches?(other)
-        end
-
-        private
-
-        def assert_ivars *ivars
-          raise "#{self.class.name} needs to supply #{to_sentence ivars}" unless ivars.all? { |v| instance_variables.map(&:intern).include? v }
-        end
-      end
-    end
-  end
-end

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

@@ -1,213 +0,0 @@
-require 'rspec/matchers/dsl'
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      class BeTruthy < BaseMatcher
-        def match(_, actual)
-          !!actual
-        end
-
-        def failure_message_for_should
-          "expected: truthy value\n     got: #{actual.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected: falsey value\n     got: #{actual.inspect}"
-        end
-      end
-
-      class BeFalsey < BaseMatcher
-        def match(_, actual)
-          !actual
-        end
-
-        def failure_message_for_should
-          "expected: falsey value\n     got: #{actual.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected: truthy value\n     got: #{actual.inspect}"
-        end
-      end
-
-      class BeNil < BaseMatcher
-        def match(_, actual)
-          actual.nil?
-        end
-
-        def failure_message_for_should
-          "expected: nil\n     got: #{actual.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected: not nil\n     got: nil"
-        end
-      end
-
-      module BeHelpers
-        private
-
-        def args_to_s
-          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
-        end
-
-        def parenthesize(string)
-          "(#{string})"
-        end
-
-        def inspected_args
-          @args.collect{|a| a.inspect}
-        end
-
-        def expected_to_sentence
-          split_words(@expected)
-        end
-
-        def args_to_sentence
-          to_sentence(@args)
-        end
-      end
-
-      class Be < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @args = args
-        end
-
-        def match(_, actual)
-          !!actual
-        end
-
-        def failure_message_for_should
-          "expected #{@actual.inspect} to evaluate to true"
-        end
-
-        def failure_message_for_should_not
-          "expected #{@actual.inspect} to evaluate to false"
-        end
-
-        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
-          define_method operator do |operand|
-            BeComparedTo.new(operand, operator)
-          end
-        end
-      end
-
-      class BeComparedTo < Be
-        def initialize(operand, operator)
-          @expected, @operator = operand, operator
-            @args = []
-        end
-
-        def matches?(actual)
-          @actual = actual
-          @actual.__send__ @operator, @expected
-        end
-
-        def failure_message_for_should
-          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
-        end
-
-        def failure_message_for_should_not
-          message = <<-MESSAGE
-`#{negative_expectation_expression}` not only FAILED,
-it is a bit confusing.
-          MESSAGE
-
-          raise message << ([:===,:==].include?(@operator) ?
-                            "It might be more clearly expressed without the \"be\"?" :
-                            "It might be more clearly expressed in the positive?")
-        end
-
-        def description
-          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
-        end
-
-        def negative_expectation_expression
-          Expectations::Syntax.negative_expression("actual", "be #{@operator} #{@expected}")
-        end
-      end
-
-      class BePredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
-        end
-
-        def matches?(actual)
-          @actual = actual
-
-          if is_private_on?( @actual )
-            raise Expectations::ExpectationNotMetError.new("expectation set on private method `#{predicate}`")
-          end
-
-          begin
-            return @result = actual.__send__(predicate, *@args, &@block)
-          rescue NameError => predicate_missing_error
-            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
-          end
-
-          begin
-            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
-          rescue NameError
-            raise predicate_missing_error
-          end
-        end
-
-        alias === matches?
-
-        def failure_message_for_should
-          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
-        end
-
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-        end
-
-        private
-
-        # support 1.8.7
-        if methods.first.is_a? String
-          def is_private_on? actual
-            actual.private_methods.include? predicate.to_s
-          end
-        else
-          def is_private_on? actual
-            actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate
-          "#{@expected}?".to_sym
-        end
-
-        def present_tense_predicate
-          "#{@expected}s?".to_sym
-        end
-
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
-        end
-
-        def prefix_and_expected(symbol)
-          symbol.to_s =~ /^(be_(an?_)?)(.*)/
-          return $1, $3
-        end
-
-        def prefix_to_sentence
-          split_words(@prefix)
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class BeWithin
-        def initialize(delta)
-          @delta = delta
-        end
-
-        def matches?(actual)
-          @actual = actual
-          raise needs_expected     unless defined? @expected
-          raise needs_subtractable unless @actual.respond_to? :-
-          (@actual - @expected).abs <= @tolerance
-        end
-        alias == matches?
-
-        def of(expected)
-          @expected  = expected
-          @tolerance = @delta
-          @unit      = ''
-          self
-        end
-
-        def percent_of(expected)
-          @expected  = expected
-          @tolerance = @delta * @expected.abs / 100.0
-          @unit      = '%'
-          self
-        end
-
-        def failure_message_for_should
-          "expected #{@actual} to #{description}"
-        end
-
-        def failure_message_for_should_not
-          "expected #{@actual} not to #{description}"
-        end
-
-        def description
-          "be within #{@delta}#{@unit} of #{@expected}"
-        end
-
-        private
-
-        def needs_subtractable
-          ArgumentError.new "The actual value (#{@actual.inspect}) must respond to `-`"
-        end
-
-        def needs_expected
-          ArgumentError.new "You must set an expected value using #of: be_within(#{@delta}).of(expected_value)"
-        end
-      end
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Change
-        def initialize(receiver=nil, message=nil, &block)
-          @message = message
-          @value_proc = block || lambda {receiver.__send__(message)}
-          @expected_after = @expected_before = @minimum = @maximum = @expected_delta = nil
-          @eval_before = @eval_after = false
-        end
-
-        def matches?(event_proc)
-          raise_block_syntax_error if block_given?
-
-          @actual_before = evaluate_value_proc
-          event_proc.call
-          @actual_after = evaluate_value_proc
-
-          (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
-        end
-        alias == matches?
-
-        def raise_block_syntax_error
-          raise SyntaxError.new(<<-MESSAGE)
-block passed to should or should_not change must use {} instead of do/end
-MESSAGE
-        end
-
-        def evaluate_value_proc
-          case val = @value_proc.call
-          when Enumerable, String
-            val.dup
-          else
-            val
-          end
-        end
-
-        def failure_message_for_should
-          if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
-            "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
-          elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
-            "#{message} should have been changed to #{failure_message_for_expected_after}, but is now #{@actual_after.inspect}"
-          elsif @expected_delta
-            "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
-          elsif @minimum
-            "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
-          elsif @maximum
-            "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
-          else
-            "#{message} should have changed, but is still #{@actual_before.inspect}"
-          end
-        end
-
-        def actual_delta
-          @actual_after - @actual_before
-        end
-
-        def failure_message_for_should_not
-          "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
-        end
-
-        def by(expected_delta)
-          @expected_delta = expected_delta
-          self
-        end
-
-        def by_at_least(minimum)
-          @minimum = minimum
-          self
-        end
-
-        def by_at_most(maximum)
-          @maximum = maximum
-          self
-        end
-
-        def to(to)
-          @eval_after = true
-          @expected_after = to
-          self
-        end
-
-        def from (before)
-          @eval_before = true
-          @expected_before = before
-          self
-        end
-
-        def description
-          "change ##{message}"
-        end
-
-        private
-
-        def failure_message_for_expected_after
-          if RSpec::Matchers.is_a_matcher?(@expected_after)
-            @expected_after.description
-          else
-            @expected_after.inspect
-          end
-        end
-
-        def message
-          @message || "result"
-        end
-
-        def change_expected?
-          @expected_delta != 0
-        end
-
-        def changed?
-          @actual_before != @actual_after
-        end
-
-        def matches_before?
-          @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
-        end
-
-        def matches_after?
-          @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
-        end
-
-        def matches_expected_delta?
-          @expected_delta ? (@actual_before + @expected_delta == @actual_after) : true
-        end
-
-        def matches_min?
-          @minimum ? (@actual_after - @actual_before >= @minimum) : true
-        end
-
-        def matches_max?
-          @maximum ? (@actual_after - @actual_before <= @maximum) : true
-        end
-
-        def expected_matches_actual?(expected, actual)
-          expected === actual || actual == expected
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Eq < BaseMatcher
-        def match(expected, actual)
-          actual == expected
-        end
-
-        def failure_message_for_should
-          "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
-        end
-
-        def failure_message_for_should_not
-          "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
-        end
-
-        def diffable?; true; end
-      end
-    end
-  end
-end
-

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

@@ -1,48 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Equal < BaseMatcher
-        def match(expected, actual)
-          actual.equal? expected
-        end
-
-        def failure_message_for_should
-          return <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`#{eq_expression}` if you don't care about
-object identity in this example.
-
-MESSAGE
-        end
-
-        def failure_message_for_should_not
-          return <<-MESSAGE
-
-expected not #{inspect_object(actual)}
-         got #{inspect_object(expected)}
-
-Compared using equal?, which compares object identity.
-
-MESSAGE
-        end
-
-        def diffable?; true; end
-
-        private
-
-        def inspect_object(o)
-          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
-        end
-
-        def eq_expression
-          Expectations::Syntax.positive_expression("actual", "eq(expected)")
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Exist < BaseMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        def matches?(actual)
-          @actual = actual
-          predicates = [:exist?, :exists?].select { |p| @actual.respond_to?(p) }
-          existence_values = predicates.map { |p| @actual.__send__(p, *@expected) }
-          uniq_truthy_values = existence_values.map { |v| !!v }.uniq
-
-          case uniq_truthy_values.size
-          when 0; raise NoMethodError.new("#{@actual.inspect} does not respond to either #exist? or #exists?")
-          when 1; existence_values.first
-          else raise "#exist? and #exists? returned different values:\n\n" +
-            " exist?: #{existence_values.first}\n" +
-            "exists?: #{existence_values.last}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Has
-        def initialize(expected, *args)
-          @expected, @args = expected, args
-        end
-
-        def matches?(actual)
-          actual.__send__(predicate(@expected), *@args)
-        end
-        alias == matches?
-
-        def failure_message_for_should
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
-        end
-
-        def failure_message_for_should_not
-          "expected ##{predicate(@expected)}#{failure_message_args_description} to return false, got true"
-        end
-
-        def description
-          [method_description(@expected), args_description].compact.join(' ')
-        end
-
-        private
-
-        def predicate(sym)
-          "#{sym.to_s.sub("have_","has_")}?".to_sym
-        end
-
-        def method_description(method)
-          method.to_s.gsub('_', ' ')
-        end
-
-        def args_description
-          return nil if @args.empty?
-          @args.map { |arg| arg.inspect }.join(', ')
-        end
-
-        def failure_message_args_description
-          desc = args_description
-          "(#{desc})" if desc
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Include < BaseMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        def matches?(actual)
-          @actual = actual
-          perform_match(:all?, :all?, @actual, @expected)
-        end
-
-        def does_not_match?(actual)
-          @actual = actual
-          perform_match(:none?, :any?, @actual, @expected)
-        end
-
-        def description
-          "include#{expected_to_sentence}"
-        end
-
-        def diffable?
-          # Matchers do not diff well, since diff uses their inspect
-          # output, which includes their instance variables and such.
-          @expected.none? { |e| RSpec::Matchers.is_a_matcher?(e) }
-        end
-
-        private
-
-        def perform_match(predicate, hash_predicate, actuals, expecteds)
-          expecteds.__send__(predicate) do |expected|
-            if comparing_hash_values?(actuals, expected)
-              expected.__send__(hash_predicate) { |k,v|
-                actuals.has_key?(k) && actuals[k] == v
-              }
-            elsif comparing_hash_keys?(actuals, expected)
-              actuals.has_key?(expected)
-            elsif comparing_with_matcher?(actual, expected)
-              actual.any? { |value| expected.matches?(value) }
-            else
-              actuals.include?(expected)
-            end
-          end
-        end
-
-        def comparing_hash_keys?(actual, expected)
-          actual.is_a?(Hash) && !expected.is_a?(Hash)
-        end
-
-        def comparing_hash_values?(actual, expected)
-          actual.is_a?(Hash) && expected.is_a?(Hash)
-        end
-
-        def comparing_with_matcher?(actual, expected)
-          actual.is_a?(Array) && RSpec::Matchers.is_a_matcher?(expected)
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Match < BaseMatcher
-
-        def match(expected, actual)
-          actual.match expected
-        end
-
-        def diffable?
-          true
-        end
-
-      end
-    end
-  end
-end