rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/cover.rb

@@ -1,36 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if actual covers expected. This works for
-    # Ranges. You can also pass in multiple args
-    # and it will only pass if all args are found in Range.
-    #
-    # @example
-    #   (1..10).should cover(5)
-    #   (1..10).should cover(4, 6)
-    #   (1..10).should cover(4, 6, 11) # will fail
-    #   (1..10).should_not cover(11)
-    #   (1..10).should_not cover(5)    # will fail
-    #
-    # ### Warning:: Ruby >= 1.9 only
-    def cover(*values)
-      Cover.new(*values)
-    end
-  end
-end

data/lib/rspec/matchers/eq.rb

@@ -1,36 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if <tt>actual == expected</tt>.
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # @example
-    #
-    #   5.should eq(5)
-    #   5.should_not eq(3)
-    def eq(expected)
-      Eq.new(expected)
-    end
-  end
-end
-

data/lib/rspec/matchers/eql.rb

@@ -1,35 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if +actual.eql?(expected)+
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # @example
-    #
-    #   5.should eql(5)
-    #   5.should_not eql(3)
-    def eql(expected)
-      Eql.new(expected)
-    end
-  end
-end

data/lib/rspec/matchers/equal.rb

@@ -1,58 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if <tt>actual.equal?(expected)</tt> (object identity).
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # @example
-    #
-    #   5.should equal(5) # Fixnums are equal
-    #   "5".should_not equal("5") # Strings that look the same are not the same object
-    def equal(expected)
-      Equal.new(expected)
-    end
-  end
-end

data/lib/rspec/matchers/errors.rb

@@ -1,5 +0,0 @@
-module RSpec
-  module Matchers
-    class MatcherError < StandardError; end
-  end
-end

data/lib/rspec/matchers/exist.rb

@@ -1,34 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if `actual.exist?` or `actual.exists?`
-    #
-    # @example
-    #   File.should exist("path/to/file")
-    def exist(*args)
-      Exist.new(*args)
-    end
-  end
-end

data/lib/rspec/matchers/has.rb

@@ -1,44 +0,0 @@
-module RSpec
-  module Matchers
-    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

data/lib/rspec/matchers/have.rb

@@ -1,162 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if receiver is a collection with the submitted number of items OR
-    # if the receiver OWNS a collection with the submitted number of items.
-    #
-    # If the receiver OWNS the collection, you must use the name of the
-    # collection. So if a `Team` instance has a collection named `#players`,
-    # you must use that name to set the expectation.
-    #
-    # If the receiver IS the collection, you can use any name you like for
-    # `named_collection`. We'd recommend using either "elements", "members", or
-    # "items" as these are all standard ways of describing the things IN a
-    # collection.
-    #
-    # This also works for Strings, letting you set expectations about their
-    # lengths.
-    #
-    # @example
-    #
-    #   # Passes if team.players.size == 11
-    #   team.should have(11).players
-    #
-    #   # Passes if [1,2,3].length == 3
-    #   [1,2,3].should have(3).items #"items" is pure sugar
-    #
-    #   # Passes if ['a', 'b', 'c'].count == 3
-    #   [1,2,3].should have(3).items #"items" is pure sugar
-    #
-    #   # Passes if "this string".length == 11
-    #   "this string".should have(11).characters #"characters" is pure sugar
-    def have(n)
-      Matchers::Have.new(n)
-    end
-    alias :have_exactly :have
-
-    # Exactly like have() with >=.
-    #
-    # @example
-    #   "this".should have_at_least(3).letters
-    #
-    # ### Warning:
-    #
-    # `should_not have_at_least` is not supported
-    def have_at_least(n)
-      Matchers::Have.new(n, :at_least)
-    end
-
-    # Exactly like have() with <=.
-    #
-    # @example
-    #   should have_at_most(number).items
-    #
-    # ### Warning:
-    #
-    # `should_not have_at_most` is not supported
-    def have_at_most(n)
-      Matchers::Have.new(n, :at_most)
-    end
-  end
-end

data/lib/rspec/matchers/include.rb

@@ -1,66 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if actual includes expected. This works for
-    # collections and Strings. You can also pass in multiple args
-    # and it will only pass if all args are found in collection.
-    #
-    # @example
-    #
-    #   [1,2,3].should include(3)
-    #   [1,2,3].should include(2,3) #would pass
-    #   [1,2,3].should include(2,3,4) #would fail
-    #   [1,2,3].should_not include(4)
-    #   "spread".should include("read")
-    #   "spread".should_not include("red")
-    def include(*expected)
-      Include.new(*expected)
-    end
-  end
-end