opal-rspec-cj 0.4.4

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

@@ -0,0 +1,21 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Cover < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(range)
+          @actual = range
+          @expected.all? { |e| range.cover?(e) }
+        end
+
+        def does_not_match?(range)
+          @actual = range
+          expected.none? { |e| range.cover?(e) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+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/eql.rb

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

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

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

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

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

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

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

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

@@ -0,0 +1,51 @@
+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/raise_error.rb

@@ -0,0 +1,154 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RaiseError
+        def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+          @block = block
+          @actual_error = nil
+          case expected_error_or_message
+          when String, Regexp
+            @expected_error, @expected_message = Exception, expected_error_or_message
+          else
+            @expected_error, @expected_message = expected_error_or_message, expected_message
+          end
+        end
+
+        def with_message(expected_message)
+          raise_message_already_set if @expected_message
+          @expected_message = expected_message
+          self
+        end
+
+        def matches?(given_proc, negative_expectation = false, &block)
+          @block ||= block
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+
+          unless given_proc.respond_to?(:call)
+            ::Kernel.warn "`raise_error` was called with non-proc object #{given_proc.inspect}"
+            return false
+          end
+
+          begin
+            given_proc.call
+          rescue Exception => @actual_error
+            if @actual_error == @expected_error || @expected_error === @actual_error
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
+          end
+
+          unless negative_expectation
+            eval_block if @raised_expected_error && @with_expected_message && @block
+          end
+
+          expectation_matched?
+        end
+
+        alias == matches?
+
+        def expectation_matched?
+          error_and_message_match? && block_matches?
+        end
+
+        def error_and_message_match?
+          @raised_expected_error && @with_expected_message
+        end
+
+        def block_matches?
+          @eval_block ? @eval_block_passed : true
+        end
+
+        def does_not_match?(given_proc)
+          prevent_invalid_expectations
+          !matches?(given_proc, :negative_expectation)
+        end
+
+        def eval_block
+          @eval_block = true
+          begin
+            @block[@actual_error]
+            @eval_block_passed = true
+          rescue Exception => err
+            @actual_error = err
+          end
+        end
+
+        def verify_message
+          case @expected_message
+          when nil
+            true
+          when Regexp
+            @expected_message =~ @actual_error.message
+          else
+            @expected_message == @actual_error.message
+          end
+        end
+
+        def failure_message_for_should
+          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+        end
+
+        def failure_message_for_should_not
+          "expected no #{expected_error}#{given_error}"
+        end
+
+        def description
+          "raise #{expected_error}"
+        end
+
+        private
+
+        def prevent_invalid_expectations
+          if (expecting_specific_exception? || @expected_message)
+            what_to_raise = if expecting_specific_exception? && @expected_message
+                                  "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                                elsif expecting_specific_exception?
+                                  "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                                elsif @expected_message
+                                  "`expect { }.not_to raise_error(message)`"
+                                end
+            specific_class_error = ArgumentError.new("#{what_to_raise} is not valid, use `expect { }.not_to raise_error` (with no args) instead")
+            raise specific_class_error
+          end
+        end
+
+        def expected_error
+          case @expected_message
+          when nil
+            @expected_error.inspect
+          when Regexp
+            "#{@expected_error} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_error} with #{@expected_message.inspect}"
+          end
+        end
+
+        def format_backtrace(backtrace)
+          formatter = Matchers.configuration.backtrace_formatter
+          formatter.format_backtrace(backtrace)
+        end
+
+        def given_error
+          return " but nothing was raised" unless @actual_error
+
+          backtrace = format_backtrace(@actual_error.backtrace)
+          [
+            ", got #{@actual_error.inspect} with backtrace:",
+            *backtrace
+          ].join("\n  # ")
+        end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
+
+        def raise_message_already_set
+          raise "`expect { }.to raise_error(message).with_message(message)` is not valid. The matcher only allows the expected message to be specified once"
+        end
+      end
+    end
+  end
+end