rspec-expectations 2.8.0 → 2.9.0.rc2

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

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

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

@@ -0,0 +1,26 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Eq
+        include BaseMatcher
+
+        def matches?(actual)
+          super(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/lib/rspec/matchers/built_in/eql.rb

@@ -0,0 +1,25 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Eql
+        include BaseMatcher
+
+        def matches?(actual)
+          super(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/lib/rspec/matchers/built_in/equal.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Equal
+        include BaseMatcher
+
+        def matches?(actual)
+          super(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
+'actual.should == expected' 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Exist
+        include BaseMatcher
+
+        def initialize(*args)
+          super(args)
+        end
+
+        def matches?(actual)
+          super(actual)
+          predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
+          existance_values = predicates.map { |p| actual.send(p, *expected) }
+          uniq_truthy_values = existance_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; existance_values.first
+          else raise "#exist? and #exists? returned different values:\n\n" +
+            " exist?: #{existance_values.first}\n" +
+            "exists?: #{existance_values.last}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+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
+
+        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/lib/rspec/matchers/built_in/have.rb

@@ -0,0 +1,107 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Have
+        def initialize(expected, relativity=:exactly)
+          @expected = case expected
+                      when :no then 0
+                      when String then expected.to_i
+                      else expected
+                      end
+          @relativity = relativity
+          @actual = @collection_name = @plural_collection_name = nil
+        end
+
+        def relativities
+          @relativities ||= {
+            :exactly => "",
+            :at_least => "at least ",
+            :at_most => "at most "
+          }
+        end
+
+        def matches?(collection_or_owner)
+          collection = determine_collection(collection_or_owner)
+          query_method = determine_query_method(collection)
+          raise not_a_collection unless query_method
+          @actual = collection.send(query_method)
+          case @relativity
+          when :at_least then @actual >= @expected
+          when :at_most  then @actual <= @expected
+          else                @actual == @expected
+          end
+        end
+
+        def determine_collection(collection_or_owner)
+          if collection_or_owner.respond_to?(@collection_name)
+            collection_or_owner.send(@collection_name, *@args, &@block)
+          elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+            collection_or_owner.send(@plural_collection_name, *@args, &@block)
+          elsif determine_query_method(collection_or_owner)
+            collection_or_owner
+          else
+            collection_or_owner.send(@collection_name, *@args, &@block)
+          end
+        end
+
+        def determine_query_method(collection)
+          [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+        end
+
+        def not_a_collection
+          "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
+        end
+
+        def failure_message_for_should
+          "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+        end
+
+        def failure_message_for_should_not
+          if @relativity == :exactly
+            return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+          elsif @relativity == :at_most
+            return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_least(#{@expected + 1}).#{@collection_name}
+EOF
+          elsif @relativity == :at_least
+            return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_most(#{@expected - 1}).#{@collection_name}
+EOF
+          end
+        end
+
+        def description
+          "have #{relative_expectation} #{@collection_name}"
+        end
+
+        def respond_to?(m)
+          @expected.respond_to?(m) || super
+        end
+
+        private
+
+        def method_missing(method, *args, &block)
+          @collection_name = method
+          if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+            @plural_collection_name = inflector.pluralize(method.to_s)
+          end
+          @args = args
+          @block = block
+          self
+        end
+
+        def relative_expectation
+          "#{relativities[@relativity]}#{@expected}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Include
+        include BaseMatcher
+
+        def initialize(*expected)
+          super(expected)
+        end
+
+        def matches?(actual)
+          perform_match(:all?, :all?, super(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?
+          true
+        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[k] == v}
+            elsif comparing_hash_keys?(actuals, expected)
+              actuals.has_key?(expected)
+            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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Match
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).match(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class MatchArray
+        include RSpec::Matchers::Pretty
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual        
+          @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
+          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?
+          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.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/raise_error.rb

@@ -0,0 +1,96 @@
+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 matches?(given_proc)
+          @raised_expected_error = false
+          @with_expected_message = false
+          @eval_block = false
+          @eval_block_passed = false
+          begin
+            given_proc.call
+          rescue @expected_error => @actual_error
+            @raised_expected_error = true
+            @with_expected_message = verify_message
+          rescue Exception => @actual_error
+            # This clause should be empty, but rcov will not report it as covered
+            # unless something (anything) is executed within the clause
+            "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+          end
+
+          unless negative_expectation?
+            eval_block if @raised_expected_error && @with_expected_message && @block
+          end
+        ensure
+          return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+        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 expected_error
+          case @expected_message
+          when nil
+            @expected_error
+          when Regexp
+            "#{@expected_error} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_error} with #{@expected_message.inspect}"
+          end
+        end
+
+        def given_error
+          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
+        end
+
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+      end
+    end
+  end
+end