rspec-sleeping_king_studios 1.0.0.rc.2

data/lib/rspec/sleeping_king_studios/matchers/active_model/have_errors/error_expectation.rb

@@ -0,0 +1,60 @@
+# lib/rspec/sleeping_king_studios/matchers/active_model/have_errors/error_expectation.rb
+
+require 'rspec/sleeping_king_studios/matchers/base_matcher'
+require 'rspec/sleeping_king_studios/matchers/active_model/have_errors/message_expectation'
+
+module RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrors
+  # Stores an expectation of receiving an error for a specified attribute, as
+  # well as zero or more message expectations.
+  # 
+  # @since 1.0.0
+  #
+  # @see MessageExpectation
+  class ErrorExpectation < Struct.new :attribute, :expected, :received
+    # Extra instance methods for the :messages array.
+    # 
+    # @private
+    module MessagesMethods
+      # @return [Array<MessageExpectation>] messages that are expected
+      def expected
+        select { |message| message.expected }
+      end # method expected
+
+      # @return [Array<MessageExpectation>] messages that are expected but have
+      #   not been received
+      def missing
+        select { |message| message.expected && !message.received }
+      end # method missing
+
+      # @return [Array<MessageExpectation>] messages that have been received
+      def received
+        select { |message| message.received }
+      end # method received
+    end # module
+
+    # @param [String, Symbol] attribute the attribute for which an error is
+    #   expected to be or has been received
+    # @param [Boolean] expected whether an error is expected for the specified
+    #   attribute
+    # @param [Boolean] received whether an error has been received for the
+    #   specified attribute
+    def initialize attribute, expected = true, received = false
+      super attribute.intern, expected, received
+
+      @messages = []
+      class << @messages
+        include MessagesMethods
+      end # eigenclass
+    end # constructor
+
+    # The message expectations for the specified attribute. The returned array
+    # supports several additional methods: #expected, #missing, and #received.
+    # 
+    # @return [Array<MessageExpectation>]
+    # 
+    # @see MessagesMethods#expected
+    # @see MessagesMethods#missing
+    # @see MessagesMethods#received
+    attr_reader :messages
+  end # class
+end # module

data/lib/rspec/sleeping_king_studios/matchers/active_model/have_errors/message_expectation.rb

@@ -0,0 +1,17 @@
+# lib/rspec/sleeping_king_studios/matchers/active_model/have_errors/message_expectation.rb
+
+require 'rspec/sleeping_king_studios/matchers/base_matcher'
+require 'rspec/sleeping_king_studios/matchers/active_model/have_errors/require'
+
+module RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrors
+  # Stores an expectation of receiving a specified error message.
+  class MessageExpectation < Struct.new :message, :expected, :received
+    # @param [String] message the message which is expected to be or has been
+    #   received
+    # @param [Boolean] expected whether the message is expected
+    # @param [Boolean] received whether the message has been received
+    def initialize message, expected = true, received = false
+      super message, expected, received
+    end # constructor
+  end # class
+end # module

data/lib/rspec/sleeping_king_studios/matchers/active_model/have_errors/require.rb

@@ -0,0 +1,7 @@
+# spec/rspec/sleeping_king_studios/matchers/active_model/have_errors/require.rb
+
+require 'rspec/sleeping_king_studios/matchers/active_model/require'
+
+module RSpec::SleepingKingStudios::Matchers::ActiveModel
+  module HaveErrors; end
+end # module

data/lib/rspec/sleeping_king_studios/matchers/active_model/require.rb

@@ -0,0 +1,8 @@
+# lib/rspec/sleeping_king_studios/matchers/active_model/require.rb
+
+require 'rspec/sleeping_king_studios/matchers/require'
+
+module RSpec::SleepingKingStudios::Matchers
+  # Matchers for ActiveModel object validation testing.
+  module ActiveModel; end
+end # module

data/lib/rspec/sleeping_king_studios/matchers/base_matcher.rb

@@ -0,0 +1,43 @@
+# lib/rspec/sleeping_king_studios/matchers/base_matcher.rb
+
+require 'rspec/sleeping_king_studios/matchers/require'
+
+module RSpec::SleepingKingStudios::Matchers
+  # Minimal implementation of the RSpec matcher interface.
+  # 
+  # @since 1.0.0
+  class BaseMatcher
+    def initialize *args
+    end # constructor
+
+    # A short string that describes the purpose of the matcher.
+    # 
+    # @return [String] the matcher description
+    def description
+      "match"
+    end # method description
+
+    # Tests the actual object to see if it matches the defined condition(s).
+    # Invoked by RSpec expectations.
+    #
+    # @param [Object] actual the object to test against the matcher
+    # 
+    # @return [Boolean] true if the object matches, otherwise false
+    def matches? actual
+      @actual = actual
+      true
+    end # method matches?
+
+    # Message for when the object does not match, but was expected to. Make
+    # sure to always call #matches? first to set up the matcher state.
+    def failure_message_for_should
+      "expected #{@actual.inspect} to #{description}"
+    end # method failure_message_for_should
+
+    # Message for when the object matches, but was expected not to. Make sure
+    # to always call #matches? first to set up the matcher state.
+    def failure_message_for_should_not
+      "expected #{@actual.inspect} not to #{description}"
+    end # method failure_message_for_should_not
+  end # class
+end # module

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

@@ -0,0 +1,5 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in.rb
+
+Dir[File.join File.dirname(__FILE__), 'built_in', '*.rb'].each do |file|
+  require file
+end # end each

data/lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb

@@ -0,0 +1,68 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb
+
+require 'rspec/sleeping_king_studios/matchers/built_in/require'
+
+module RSpec::SleepingKingStudios::Matchers::BuiltIn
+  class BeAKindOfMatcher < RSpec::Matchers::BuiltIn::BeAKindOf
+    # Checks if the object matches one of the specified types. Allows an
+    # expected value of nil as a shortcut for expecting an instance of
+    # NilClass.
+    # 
+    # @param [Module, nil, Array<Module, nil>] expected the type or types to
+    #   check the object against
+    # @param [Object] actual the object to check
+    # 
+    # @return [Boolean] true if the object matches one of the specified types,
+    #   otherwise false
+    def match expected, actual
+      match_type? expected
+    end # method match
+
+    # @see BaseMatcher#failure_message_for_should
+    def failure_message_for_should
+      "expected #{@actual.inspect} to be #{type_string}"
+    end # method failure_message_for_should
+    
+    # @see BaseMatcher#failure_message_for_should_not
+    def failure_message_for_should_not
+      "expected #{@actual.inspect} not to be #{type_string}"
+    end # method failure_message_for_should_not
+
+    private
+    
+    def match_type? expected
+      case
+      when expected.nil?
+        @actual.nil?
+      when expected.is_a?(Enumerable)
+        expected.reduce(false) { |memo, obj| memo || match_type?(obj) }
+      else
+        @actual.kind_of? expected
+      end # case
+    end # method match_type?
+
+    def type_string
+      case
+      when @expected.nil?
+        @expected.inspect
+      when @expected.is_a?(Enumerable) && 1 < @expected.count
+        if 2 == expected.count
+          "a #{expected.first.inspect} or #{expected.last.inspect}"
+        else
+          "a #{expected[0..-2].map(&:inspect).join(", ")}, or #{expected.last.inspect}"
+        end # if-else
+      else
+        "a #{expected}"
+      end # case
+    end # method type_string
+  end # class
+end # module
+
+module RSpec::SleepingKingStudios::Matchers
+  # @see RSpec::SleepingKingStudios::Matchers::BuiltIn::BeAKindOfMatcher#match
+  def be_kind_of expected
+    RSpec::SleepingKingStudios::Matchers::BuiltIn::BeAKindOfMatcher.new expected
+  end # method be_kind_of
+
+  alias_method :be_a, :be_kind_of
+end # module

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

@@ -0,0 +1,92 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb
+
+require 'rspec/sleeping_king_studios/matchers/built_in/require'
+
+module RSpec::SleepingKingStudios::Matchers::BuiltIn
+  class IncludeMatcher < RSpec::Matchers::BuiltIn::Include
+    # @param [Array<Hash, Proc, Object>] expected the items expected to be
+    #   matched by the actual object
+    # 
+    # @yield if a block is provided, the block is converted to a proc and
+    #   appended to the item expectations
+    # @yieldparam [Object] item an item from the actual object; yield(item)
+    #   should return true if and only if the item matches the desired
+    #    predicate
+    def initialize *expected, &block
+      expected << block if block_given?
+      super *expected
+    end # constructor
+
+    # Checks if the object includes the specified objects. Proc expectations
+    # are evaluated by passing each item to proc#call.
+    # 
+    # @param [Object] actual the object to check
+    # 
+    # @return [Boolean] true if for each item expectation, the object contains
+    #   an item matching that expectation; otherwise false
+    def matches? actual
+      super
+    end # method matches?
+
+    # @private
+    def name
+      "include"
+    end # method name
+
+    # @private
+    def to_word item
+      case
+      when is_matcher_with_description?(item)
+        item.description
+      when Proc === item
+        "matching block"
+      else
+        item.inspect
+      end # case
+    end # method to_word
+
+    # @see BaseMatcher#failure_message_for_should
+    def failure_message_for_should
+      return "expected #{@actual.inspect} to respond to :include?" if false === @includes
+
+      super
+    end # method failure_message_for_should
+
+    # @see BaseMatcher#failure_message_for_should_not
+    def failure_message_for_should_not
+      super
+    end # method
+
+    private
+
+    def perform_match predicate, hash_predicate, actuals, expecteds
+      expecteds.__send__(predicate) do |expected|
+        if comparing_proc? actuals, expected
+          !!actuals.detect { |actual| expected.call(actual) }
+        elsif 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
+          @includes = actuals.respond_to?(:include?)
+          @includes && actuals.include?(expected)
+        end # if-elsif-end
+      end # send
+    end # method perform_match
+
+    def comparing_proc? actual, expected
+      expected.is_a?(Proc)
+    end # method comparing_proc?
+  end # class
+end # module
+
+module RSpec::SleepingKingStudios::Matchers
+  # @see RSpec::SleepingKingStudios::Matchers::BuiltIn::IncludeMatcher#matches?
+  def include *expected, &block
+    RSpec::SleepingKingStudios::Matchers::BuiltIn::IncludeMatcher.new *expected, &block
+  end # method include
+end # module

data/lib/rspec/sleeping_king_studios/matchers/built_in/require.rb

@@ -0,0 +1,7 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/require.rb
+
+require 'rspec/sleeping_king_studios/matchers/require'
+
+module RSpec::SleepingKingStudios::Matchers
+  module BuiltIn; end
+end # module

data/lib/rspec/sleeping_king_studios/matchers/built_in/respond_to.rb

@@ -0,0 +1,187 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/respond_to.rb
+
+require 'rspec/sleeping_king_studios/matchers/base_matcher'
+require 'rspec/sleeping_king_studios/matchers/built_in/require'
+require 'rspec/sleeping_king_studios/matchers/shared/match_parameters'
+
+module RSpec::SleepingKingStudios::Matchers::BuiltIn
+  class RespondToMatcher < RSpec::Matchers::BuiltIn::RespondTo
+    include RSpec::SleepingKingStudios::Matchers::Shared::MatchParameters
+
+    # Checks if the object responds to the specified message. If so, checks the
+    # parameters against the expected parameters, if any.
+    # 
+    # @param [Object] actual the object to check
+    # 
+    # @return [Boolean] true if the object responds to the message and accepts
+    #   the specified parameters; otherwise false
+    def matches? actual
+      super
+    end # method matches?
+
+    # Adds a parameter count expectation and/or one or more keyword
+    # expectations (Ruby 2.0 only).
+    # 
+    # @param [Integer, Range, nil] count the number of expected parameters; can
+    #   be an integer, a range, or nil (parameter count is ignored)
+    # @param [Array<String, Symbol>] keywords list of keyword arguments
+    #   accepted by the method
+    # 
+    # @return [RespondToMatcher] self
+    def with count = nil, *keywords
+      @expected_arity    = count unless count.nil?
+      @expected_keywords = keywords
+      self
+    end # method with
+
+    # Adds a block expectation. The actual object will only match a block
+    # expectation if it expects a parameter of the form &block.
+    # 
+    # @return [RespondToMatcher] self
+    def a_block
+      @expected_block = true
+      self
+    end # method a_block
+
+    # Convenience method for more fluent specs. Does nothing and returns self.
+    # 
+    # @return [RespondToMatcher] self
+    def arguments
+      self
+    end # method arguments
+
+    # Convenience method for more fluent specs. Does nothing and returns self.
+    # 
+    # @return [RespondToMatcher] self
+    def and
+      self
+    end # method arguments
+
+    # @see BaseMatcher#failure_message_for_should
+    def failure_message_for_should
+      messages = []
+      @failing_method_names ||= []
+      @failing_method_names.map do |method|
+        message = "expected #{@actual.inspect} to respond to #{method.inspect}"
+        if @actual.respond_to?(method)
+          message << " with arguments:\n#{format_errors_for_method method}"
+        end # if-else
+        messages << message
+      end # method
+      messages.join "\n"
+    end # method failure_message_for_should
+
+    # @see BaseMatcher#failure_message_for_should_not
+    def failure_message_for_should_not
+      @failing_method_names ||= []
+      methods, messages = @names - @failing_method_names, []
+
+      @names.map do |method|
+        message   = "expected #{@actual.inspect} not to respond to #{method.inspect}"
+        unless (formatted = format_expected_arguments).empty?
+          message << " with #{formatted}"
+        end # unless
+        messages << message
+      end # method
+      messages.join "\n"
+    end # method failure_message_for_should_not
+
+    private
+
+    def find_failing_method_names actual, filter_method
+      @actual = actual
+      @failing_method_reasons = {}
+      @failing_method_names   = @names.__send__(filter_method) do |name|
+        @actual.respond_to?(name) &&
+          matches_arity?(actual, name) &&
+          matches_keywords?(actual, name) &&
+          matches_block?(actual, name)
+      end # send
+    end # method find_failing_method_names
+
+    def matches_arity? actual, name
+      return true unless @expected_arity
+
+      if result = check_method_arity(actual.method(name), @expected_arity)
+        (@failing_method_reasons[name] ||= {}).update result
+        return false
+      end # if
+
+      true
+    end # method matches_arity?
+
+    def matches_keywords? actual, name
+      return true unless @expected_keywords
+
+      if result = check_method_keywords(actual.method(name), @expected_keywords)
+        (@failing_method_reasons[name] ||= {}).update result
+        return false
+      end # if
+
+      true
+    end # method matches_keywords?
+    
+    def matches_block? actual, name
+      return true unless @expected_block
+
+      if result = check_method_block(@actual.method(name))
+        (@failing_method_reasons[name] ||= {}).update result
+        return false
+      end # if
+
+      true
+    end # method matches_block?
+
+    def format_expected_arguments
+      messages = []
+      
+      if !@expected_arity.nil?
+        messages << "#{@expected_arity.inspect} argument#{1 == @expected_arity ? "" : "s"}"
+      end # if
+
+      if !(@expected_keywords.nil? || @expected_keywords.empty?)
+        messages << "keywords #{@expected_keywords.map(&:inspect).join(", ")}"
+      end # if
+
+      if @expected_block
+        messages << "a block"
+      end # if
+
+      case messages.count
+      when 0..1
+        messages.join(", ")
+      when 2
+        "#{messages[0]} and #{messages[1]}"
+      else
+        "#{messages[1..-1].join(", ")}, and #{messages[0]}"
+      end # case
+    end # method format_expected_arguments
+
+    def format_errors_for_method method
+      reasons, messages = @failing_method_reasons[method], []
+      
+      if hsh = reasons.fetch(:not_enough_args, false)
+        messages << "  expected at least #{hsh[:count]} arguments, but received #{hsh[:arity]}"
+      elsif hsh = reasons.fetch(:too_many_args, false)
+        messages << "  expected at most #{hsh[:count]} arguments, but received #{hsh[:arity]}"
+      end # if-elsif
+
+      if ary = reasons.fetch(:unexpected_keywords, false)
+        messages << "  unexpected keywords #{ary.map(&:inspect).join(", ")}"
+      end # if
+
+      if reasons.fetch(:expected_block, false)
+        messages << "  unexpected block"
+      end # if
+
+      messages.join "\n"
+    end # method format_errors_for_method  
+  end # class
+end # module
+
+module RSpec::SleepingKingStudios::Matchers
+  # @see RSpec::SleepingKingStudios::Matchers::BuiltIn::RespondToMatcher#matches?
+  def respond_to expected
+    RSpec::SleepingKingStudios::Matchers::BuiltIn::RespondToMatcher.new expected
+  end # method respond_to
+end # module