rspec-sleeping_king_studios 2.1.1 → 2.2.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97f6020bbdd4cef3654a94977728645b4280d887
-  data.tar.gz: 3e131e99a70932e0bc9c37beaecb603a184545f3
+  metadata.gz: c81d97b3ebb552157fcc3249abff241357da9c27
+  data.tar.gz: c1352fafecc6381179dabec958ac2942c9feadee
 SHA512:
-  metadata.gz: a68a14860a43074510e7174fd8cc94852c04226e30395c302acd28d86de417f4c9d34f3d85dce2824dc55cafc9e78b8fafb9ad1e637e4d473ac07588c739bdd6
-  data.tar.gz: 1c19caf6c928f97265aff1bddbfa5f0869d2555ee77200d28cde61d37296836df7ba642d434962be1fccc19c43709b92693471a7a01f71e08991b413a764328f
+  metadata.gz: 51ba62b4f06c179719d702fc2b77adfea0b20dcfe7296a3e2224c4a2bc2e0d5d9d9cda5690f4fc58faa3e4900ce99ece1b9e2db51709eba8478dbfefe7446126
+  data.tar.gz: 85072590a4cd2c1ed1073c8b603e46b2777036b5eb3de551804af7eb89213eb09e384448cd70eaeb7069527e077fbb68c2429a39a181851e221a37e9c25e48a9

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 2.2.0
+
+### Examples
+
+#### PropertyExamples
+
+Added examples 'should have constant' and 'should have immutable constant', which provide shortcuts for the new 'have_constant' matcher.
+
+Added examples 'should have predicate' as a shortcut for the new 'have_predicate' matcher.
+
+Added negated examples 'should not have reader' and 'should not have writer'.
+
+#### RSpecMatcherExamples
+
+Updated matcher testing examples (e.g. 'should pass with positive expectation', 'should fail with negative expectation') to support matching failure messages against strings, regular expressions, or RSpec matchers. Added configuration option for string matches to select exact match or partial/substring match.
+
+### Matchers
+
+Internally refactored all matcher definitions to *\_matcher.rb, while the previous *.rb files define the macros which are added to example groups. The file names now accurately reflect what they define. In addition, the matchers can be required separately from the macros, e.g. to get around a naming conflict with another library. Also added support for aliasing matchers.
+
+#### `alias_method` Matcher
+
+Added the `alias_method` matcher, which checks if the object aliases the specified method with the specified other name.
+
+### `construct` and `respond_to` Matchers
+
+The `construct` and `respond_to` matcher is now stricter about accepting methods with undefined argument counts. Specifically, if a method requires a minimum number of arguments, and the matcher does not have an argument count expectation but does have at least one other argument expectation (unlimited arguments, keywords, block argument, and so on), the expectation would pass on pre-2.2 versions. This is considered a bug and has been fixed. These matchers should either only check if the method is defined (if there are no argument expectations), or check that the exact argument expectations given are valid for that method.
+
+Major internal refactoring to DRY parameter matching and ensure consistent behavior between the `construct` and `respond_to` matchers.
+
+#### `belong_to` Matcher
+
+Now aliases as `a_boolean`, e.g. `expect(my_object).to have_reader(:my_method).with_value(a_boolean)`.
+
+#### `delegate_method` Matcher
+
+Added the `delegate_method` matcher, which checks if the object forwards the specified method to the specified target.
+
+#### `have_constant` Matcher
+
+Added the `have_constant` matcher, which checks for the presence of a defined constant `:CONSTANT_NAME` and optionally the value of the constant. Can also check that the value is immutable.
+
+#### `have_predicate` Matcher
+
+Added the `have_predicate` matcher, which checks for the presence of a predicate method `#property?` and optionally the value returned by `#property?()`.
+
+#### `have_reader` Matcher
+
+The `have_reader` matcher is not stricter about rejecting methods with a value expectation when negated. Previously, if the matcher was negated and had a value expectation, the matcher would only fail if the object responded to the method and returned the specified value, but would pass if the object returned another value. This is considered a bug and has been fixed, bringing this matcher in line with the behavior of the `have_property` matcher. A negated `have_reader` matcher should fail if the object responds to the method, whether or not the expected value is the same.
+
 ## 2.1.1
 
 ### Concerns
@@ -48,6 +98,8 @@ The old syntax (`respond_to(:my_method).with(1, :foo, :bar)`) will be supported
 
 Created suite of [Cucumber features](features) to validate and document the gem.
 
+### Matchers
+
 #### `construct` Matcher
 
 Aliased as `be_constructible` for more fluent specs, and the error messages have been changed from 'expected ... to construct' to 'expected ... to be constructible'.

data/DEVELOPMENT.md

@@ -1,32 +1,38 @@
 # Development Notes
 
-## Tasks
+## Version 2.2.1
+
+### Features
+
+- Implement RespondToMatcher#with_at_least(N).arguments, equivalent to with(N).arguments.and_unlimited_arguments.
+- Revisit failure messages for #respond_to, #be_constructible - see #received/#have_received for example?
+- Enhance RSpec matcher examples to display the #failure_message on a failed "should pass/fail with" example.
+
+## Future Tasks
 
 - Resolve Aruba deprecation warnings.
+- Run each file individually as CI step.
 
-### Planned Features
+### Features
 
-- Add `#with_any_keywords` alias to RespondToMatcher.
-- Add #have_constant matcher.
-- Add #have_predicate matcher.
-- Add shared examples for 'should have constant', 'should have immutable constant'
-- Add shared examples for 'should have predicate'
-- Add shared examples for 'should not have reader/writer'
-- Add shared examples for #belongs_to, #has_one, #has_many, #embedded_in, #embeds_one, #embeds_many.
-- Add shared examples for core ActiveModel validations.
-- Add allow/expect(object).to alias_method(:my_method).to(:other_method)
-- Add allow/expect(object).to delegate(:my_method).to(other_object[, :other_method])
+- Add spy+matcher for expect(my_object, :my_method).to have_changed ?
 
 ### Maintenance
 
-- Remove SCENARIOS from spec files.
-- Refactor #respond_to, #be_constructible to use RSpec 3 method reflection.
-- Revisit failure messages for #respond_to, #be_constructible.
+- Revisit how matchers are documented, particularly in README.md
+  - Use matcher class name instead of macro names?
+  - Clarify documentation of parameters - YARD-like?
 - Pare down Cucumber features for matchers - repurpose as documentation/examples only.
-- Ensure behavior of `#have_reader`, `#have_writer`, `#have_property` is consistent (non-compatible; needs version 3.0).
+  - Break down into smaller (bite-sized?) individual examples.
+- RuboCop - use RSpec rule file as starting point?
 
-### Icebox
+## Icebox
 
+- Extract ActiveModel/Rails functionality to sub-gem?
+  - Add shared examples for #belongs_to, #has_one, #has_many, #embedded_in, #embeds_one, #embeds_many.
+  - Add shared examples for core ActiveModel validations.
+  - Implement shared example group for Rails controller, 'should respond with'
+  - Implement shared example group for Rails routing, 'should route to'
 - Add alt doc test formatter - --format=list ? --format=documentation-list ?
   - Prints full expanded example name for each example
 - Add minimal test formatter - --format=smoke ? --format=librarian ? --format=quiet ?
@@ -36,3 +42,6 @@
   - #should(name) => include_examples "should #{name}"
   - #with(name)   => wrap_context "with #{name}"
   - #when(name)   => wrap_context "when #{name}"
+- General project for using matchers as Ruby objects
+  - Inspectable - expectations, comparison results exposed via readers
+  - Favor readers over instance variables.

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2013-2014 Rob Smith
+Copyright (c) 2013-2016 Rob Smith
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -4,13 +4,15 @@ A collection of matchers and extensions to ease TDD/BDD using RSpec. Extends bui
 
 ## Support
 
-RSpec::SleepingKingStudios is tested against RSpec 3.0, 3.1, 3.2, and 3.3.
+RSpec::SleepingKingStudios is tested against RSpec 3.0 through 3.4.
 
 Currently, the following versions of Ruby are officially supported:
 
-* 2.0
 * 2.1
 * 2.2
+* 2.3
+
+For Ruby 2.0 support, use version 2.1 or earlier: `gem "rspec-sleeping_king_studios", "~> 2.1.1"`.
 
 If you require a previous version of Ruby or RSpec, the 1.0 branch supports Ruby 1.9.3 and RSpec 2: `gem "rspec-sleeping_king_studios", "~> 1.0.1"`. However, changes from 2.0 and higher will not be backported.
 
@@ -28,6 +30,18 @@ Hi, I'm Rob Smith, a Ruby Engineer and the developer of this library. I use thes
 
 RSpec::SleepingKingStudios now has configuration options available through `RSpec.configuration`. For example, to set the behavior of the matcher examples when a failure message expectation is undefined (see RSpec Matcher Examples, below), put the following in your `spec_helper` or other configuration file:
 
+    RSpec.configure do |config|
+      config.sleeping_king_studios do |config|
+        # RSpec::SleepingKingStudios configuration can be set here.
+      end # config
+    end # config
+
+### Configuration Options
+
+#### Examples
+
+##### Handle Missing Failure Message With
+
     RSpec.configure do |config|
       config.sleeping_king_studios do |config|
         config.examples do |config|
@@ -36,11 +50,33 @@ RSpec::SleepingKingStudios now has configuration options available through `RSpe
       end # config
     end # config
 
-### Configuration Options
+This option is used with the RSpec matcher examples (see Examples, below), and determines the behavior when a matcher is expected to fail, but the corresponding failure message is not defined (via `let(:failure_message)` or `let(:failure_message_when_negated)`). The default option is `:pending`, which marks the generated example as skipped (and will show up as pending in the formatter). Other options include `:ignore`, which marks the generated example as passing, and `:exception`, which marks the generated example as failing.
 
-#### Handle Missing Failure Message With
+##### Match String Failure Message As
 
-This option is used with the RSpec matcher examples (see Examples, below), and determines the behavior when a matcher is expected to fail, but the corresponding failure message is not defined (via `let(:failure_message)` or `let(:failure_message_when_negated)`). The default option is `:pending`, which marks the generated example as skipped (and will show up as pending in the formatter). Other options include `:ignore`, which marks the generated example as passing, and `:exception`, which marks the generated example as failing.
+    RSpec.configure do |config|
+      config.sleeping_king_studios do |config|
+        config.examples do |config|
+          config.match_string_failure_message_as = :exact
+        end # config
+      end # config
+    end # config
+
+This option is used with the RSpec matcher examples (see Examples, below), and determines whether an expected failure message is matched against the actual failure message as an exact match or as a substring. The default option is `:substring`, which means that any failure message that contains the expected message as a substring will match. Alternatively, setting the option to `:exact` will mean that only a failure message that is an exact match for the expected message will match.
+
+#### Matchers
+
+##### Strict Predicate Matching
+
+    RSpec.configure do |config|
+      config.sleeping_king_studios do |config|
+        config.matchers do |config|
+          config.strict_predicate_matching = true
+        end # config
+      end # config
+    end # config
+
+This option is used with the HavePredicateMatcher (see `#have_predicate`, below). If set to true, ensures that any method that is expected to be a predicate will return either true or false. The matcher will fail if the method returns any other value. The default value is false, which allows for loose matching of predicate methods.
 
 ## Concerns
 
@@ -164,6 +200,12 @@ To enable a custom matcher, simply require the associated file. Matchers can be
     require 'rspec/sleeping_king_studios/matchers/core/construct'
     #=> requires only the :construct matcher
 
+As of version 2.2, you can also load only the matcher, without adding the associated macro to your example groups. This can be useful in case of naming conflicts with other libraries, or if you need only the matcher in isolation.
+
+    require 'rspec/sleeping_king_studios/matchers/core/be_boolean_matcher'
+    #=> requires the matcher itself as RSpec::SleepingKingStudios::Matchers::Core::BeBooleanMatcher,
+    #   but does not add a #be_boolean macro to example groups.
+
 ### ActiveModel
 
     require 'rspec/sleeping_king_studios/matchers/active_model/all'
@@ -254,16 +296,38 @@ Now has additional chaining functionality to validate the number of arguments ac
 
 These matchers check core functionality, such as object boolean-ness, the existence of properties, and so on.
 
+#### `#alias_method` Matcher
+
+    require 'rspec/sleeping_king_studios/matchers/core/alias_method'
+
+Checks if the object aliases the specified method with the specified other name. Matches if and only if the object responds to both the old and new method names, and if the old method and the new method are the same method.
+
+**How To Use**:
+
+    expect(object).to alias_method(:old_method).as(:new_method)
+
+**Parameters:** Old method name. Expects the name of the method which has been aliased as a String or Symbol.
+
+**Chaining:**
+
+* **`#as`:** Required. Expects one String or Symbol, which is the name of the generated method.
+
 #### `#be_boolean` Matcher
 
     require 'rspec/sleeping_king_studios/matchers/core/be_boolean'
 
 Checks if the provided object is true or false.
 
+**Aliases:** `#a_boolean`.
+
 **How To Use:**
 
+    # With an object comparison.
     expect(object).to be_boolean
 
+    # Inside a composable matcher.
+    expect(array).to include(a_boolean)
+
 **Parameters:** None.
 
 #### `#construct` Matcher
@@ -289,6 +353,73 @@ Verifies that the actual object can be constructed using `::new`. Can take an op
 * **`#with_keywords`:** (also `and_keywords`) Expects one or more String or Symbol arguments. Verifies that the class's constructor accepts each provided keyword or has a variadic keyword of the form `**params`. As of 2.1.0 and required keywords, verifies that all required keywords are provided.
 * **`#with_arbitrary_keywords`:** (also `and_arbitrary_keywords`) No parameters. Verifies that the class's constructor accepts any keyword arguments via a variadic keyword of the form `**params`.
 
+#### `#delegate_method` Matcher
+
+    require 'rspec/sleeping_king_studios/matchers/core/delegate_method'
+
+Checks if the actual object forwards the specified method to the specified target. Can also specify that arguments, keywords, and/or a block are passed to the target, and that the object returns the specified values.
+
+**How To Use:**
+
+    expect(object).to delegate_method(:my_method).to(target)
+
+    # Specify that arguments must be passed to the target.
+    expect(object).to delegate_method(:my_method).to(target).with_arguments(:ichi, :ni, :san)
+    expect(object).to delegate_method(:my_method).to(target).with_keywords(:foo => 'foo', :bar => 'bar')
+    expect(object).to delegate_method(:my_method).to(target).with_a_block
+
+    # Specify that the method must return the specified value.
+    expect(object).to delegate_method(:my_method).to(target).and_return(true)    # Called 1 time.
+    expect(object).to delegate_method(:my_method).to(target).and_return(0, 1, 2) # Called 3 times.
+
+**Parameters:** Method name. Expects a string or symbol that is a valid identifier.
+
+**Chaining:**
+
+* **`#to`:** Required. Expects an object, which is the target the method should be forwarded to.
+* **`#with_arguments`:** (also `and_arguments`) Expects one or more arguments. Specifies that when the method is called on the actual object with the given arguments, those arguments are then passed on to the target object when the method is called on the target.
+* **`#with_keywords:`** (also `and_keywords`) Expects a hash of keywords and values. Specifies that when the method is called on the actual object with the given keywords, those keywords are then passed on to the target object when the method is called on the target.
+* **`#with_a_block:`** (also `and_a_block`) Specifies that when the method is called on the actual object a block argument, thhe block is then passed on to the target object when the method is called on the target.
+* **`#and_return`:** Expects one or more arguments. The method is called on the actual object one time for each value passed into `#and_return`. Specifies that the return value of calling the method on the actual object is the corresponding value passed into `#and_return`.
+
+#### `#have_constant` Matcher
+
+    require 'rspec/sleeping_king_studios/matchers/core/have_constant'
+
+Checks for the presence of a defined constant `:CONSTANT_NAME` and optionally the value of the constant. Can also check that the value is immutable, e.g. for an additional layer of protection over important constants.
+
+**How To Use:**
+
+  expect(instance).to have_constant(:FOO)
+
+  expect(instance).to have_constant(:BAR).with_value('Bar')
+
+  expect(instance).to have_immutable_constant(:BAZ).with_value('Baz')
+
+**Parameters:** Constant name. Expects a string or symbol that is a valid identifier.
+
+**Chaining:**
+
+* **`#immutable`:** Sets a mutability expectation, which passes if the value of the constant is immutable. Values of `nil`, `false`, `true` are always immutable, as are `Numeric` and `Symbol` primitives. `Array` values must be frozen and all array items must be immutable. `Hash` values must be frozen and all hash keys and values must be immutable. All other objects must be frozen.
+
+* **`#with`:** (also `#with_value`) Expects `true` or `false`, which is checked against the current value of `actual.property?()` if actual responds to `#property?`.
+
+#### `#have_predicate` Matcher
+
+    require 'rspec/sleeping_king_studios/matchers/core/have_predicate'
+
+Checks if the actual object responds to `#property?`, and optionally if the current value of `actual.property?()` is equal to a specified value. If `config.sleeping_king_studios.matchers.strict_predicate_matching` is set to true, will also validate that the `#property?` returns either `true` or `false`.
+
+**How To Use:**
+
+  expect(instance).to have_predicate(:foo?).with(true)
+
+**Parameters:** Property. Expects a string or symbol that is a valid identifier.
+
+**Chaining:**
+
+* **`#with`:** (also `#with_value`) Expects `true` or `false`, which is checked against the current value of `actual.property?()` if actual responds to `#property?`.
+
 #### `#have_property` Matcher
 
     require 'rspec/sleeping_king_studios/matchers/core/have_property'
@@ -355,33 +486,81 @@ Unless otherwise noted, these shared examples expect the example group to define
 
 ### Property Examples
 
-These examples are shorthand for defining a reader and/or writer expectation.
+These examples are shorthand for defining a property expectation.
+
+    require 'rspec/sleeping_king_studios/examples/property_examples'
+
+    RSpec.describe MyClass do
+      include RSpec::SleepingKingStudios::Examples::PropertyExamples
+
+      # You can use the custom shared examples here.
+    end # describe
+
+#### Should Have Constant
+
+    include_examples 'should have constant', :FOO, 42
+
+Delegates to the `#have_constant` matcher (see Core/#have_constant, above) and passes if the described class defines the specified constant. If a value is specified, the class or module must define the constant with the specified value. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
+
+    include_examples 'should have property', :BAR, ->() { an_instance_of(String) }
+
+    include_examples 'should have property', :BAZ, ->(value) { value.count = 3 }
+
+#### Should Have Immutable Constant
+
+    include_examples 'should have immutable constant', :FOO, 42
+
+As the 'should have constant' example, but sets a mutability expectation on the constant. See Core/#have_constant for specifics on which objects are considered mutable.
+
+#### Should Have Predicate
+
+    include_examples 'should have predicate', :foo, true
+
+    include_examples 'should have predicate', :foo?, true
+
+Delegates to the `#have_predicate` matcher (see Core/#have_predicate, above) and passes if the actual object responds to the specified predicate. If a value is specified, the object must respond to the predicate and return the specified value, which must be true or false. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
+
+    include_examples 'should have predicate', :bar, ->() { a_boolean }
+
+    include_examples 'should have predicate', :baz, ->(value) { value == true }
+
+#### Should Have Property
+
+    include_examples 'should have property', :foo, 42
+
+Delegates to the `#have_property` matcher (see Core/#have\_property, above) and passes if the actual object responds to the specified reader and writer methods. If a value is specified, the object must respond to the property and return the specified value. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
+
+    include_examples 'should have property', :bar, ->() { an_instance_of(String) }
+
+    include_examples 'should have property', :baz, ->(value) { value.count = 3 }
+
+#### Should Have Reader
 
-#### Has Property
+    include_examples 'should have reader', :foo, 42
 
-    include_examples 'has property', :foo, 42
+Delegates to the `#have_reader` matcher (see Core/#have_reader, above) and passes if the actual object responds to the specified property reader. If a value is specified, the object must respond to the property and return the specified value. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
 
-Delegates to the `#has_reader` and `#has_writer` matchers (see Core/#has\_reader and Core/#has\_writer, above) and passes if the actual object responds to the specified property and property writer methods. If a value is specified, the object must respond to the property and return the specified value. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
+    include_examples 'should have reader', :bar, ->() { an_instance_of(String) }
 
-    include_examples 'has property', :bar, ->() { an_instance_of(String) }
+    include_examples 'should have reader', :baz, ->(value) { value.count = 3 }
 
-    include_examples 'has property', :baz, ->(value) { value.count = 3 }
+#### Should Not Have Reader
 
-#### Has Reader
+    include_examples 'should not have reader', :foo
 
-    include_examples 'has reader', :foo, 42
+Delegates to the `#have_reader` matcher (see Core/#have_reader, above) and passes if the actual object does not respond to to the specified property reader.
 
-Delegates to the `#has_reader` matcher (see Core/#has_reader, above) and passes if the actual object responds to the specified property. If a value is specified, the object must respond to the property and return the specified value. Alternatively, you can set a proc as the expected value, which can contain a comparison, an RSpec expectation, or a more complex expression:
+#### Should Have Writer
 
-    include_examples 'has reader', :bar, ->() { an_instance_of(String) }
+    include_examples 'should have writer', :foo=
 
-    include_examples 'has reader', :baz, ->(value) { value.count = 3 }
+Delegates to the `#have_writer` matcher (see Core/#have_writer, above) and passes if the actual object responds to the specified property writer.
 
-#### Has Writer
+#### Should Not Have Writer
 
-    include_examples 'has writer', :foo=
+    include_examples 'should not have writer', :foo=
 
-Delegates to the `#has_writer` matcher (see Core/#has_writer, above) and passes if the actual object responds to the specified property writer.
+Delegates to the `#have_writer` matcher (see Core/#have_writer, above) and passes if the actual object does not respond to to the specified property writer.
 
 ### RSpec Matcher Examples
 

data/lib/rspec/sleeping_king_studios/configuration.rb

@@ -10,13 +10,16 @@ module RSpec::SleepingKingStudios
       # Permitted options for :handle_missing_failure_message_with.
       MISSING_FAILURE_MESSAGE_HANDLERS = %w(ignore pending exception).map(&:intern)
 
+      # Options for matching failure messages to strings.
+      STRING_FAILURE_MESSAGE_MATCH_OPTIONS = %w(exact substring).map(&:intern)
+
       # Gets the handler for missing failure messages when using the matcher
       # examples, and sets to :pending if unset.
       #
       # @return [Symbol] The current missing message handler.
       def handle_missing_failure_message_with
         @handle_missing_failure_message_with ||= :pending
-      end # method missing_failure_message
+      end # method handle_missing_failure_message_with
 
       # Sets the handler for missing failure messages when using the matcher
       # examples.
@@ -29,11 +32,59 @@ module RSpec::SleepingKingStudios
       def handle_missing_failure_message_with= value
         unless MISSING_FAILURE_MESSAGE_HANDLERS.include?(value)
           message = "unrecognized handler value -- must be in #{MISSING_FAILURE_MESSAGE_HANDLERS.join ', '}"
+
           raise ArgumentError.new message
         end # unless
 
         @handle_missing_failure_message_with = value
-      end # message missing_failure_message=
+      end # method handle_missing_failure_message_with=
+
+      # Gets the option for matching failure messages to strings, and sets to
+      # :substring if unset.
+      #
+      # @return [Symbol] The current failure message string matching option.
+      def match_string_failure_message_as
+        @match_string_failure_message_as ||= :substring
+      end # method match_string_failure_message_as
+
+      # Sets the option for matching failure messages to strings.
+      #
+      # @param [Symbol] value The desired option. Must be :exact, :substring, or
+      #   :partial (alias of :substring).
+      #
+      # @raise ArgumentError If the handler is not one of the recognized
+      #   values.
+      def match_string_failure_message_as= value
+        value = :substring if value == :partial
+
+        unless STRING_FAILURE_MESSAGE_MATCH_OPTIONS.include?(value)
+          message = "unrecognized value -- must be in #{STRING_FAILURE_MESSAGE_MATCH_OPTIONS.join ', '}"
+
+          raise ArgumentError.new message
+        end # unless
+
+        @match_string_failure_message_as = value
+      end # method match_string_failure_message_as=
+    end # class
+
+    # Configuration options for RSpec::SleepingKingStudios::Matchers.
+    class Matchers
+      # Checks whether predicates are matched "strictly", meaning that they must
+      # return either true or false.
+      #
+      # @return [Boolean] True if predicates are strictly matched, otherwise
+      #   false.
+      def strict_predicate_matching
+        @strict_predicate_matching ||= false
+      end # method strict_predicate_matching
+
+      # Sets whether predicates are matched "strictly", meaning that they must
+      # return either true or false.
+      #
+      # @param [Boolean] value The desired value. Is coerced to true or false.
+      def strict_predicate_matching= value
+        @strict_predicate_matching = !!value
+      end # method strict_predicate_matching
     end # class
 
     # Get or set the configuration options for
@@ -45,6 +96,16 @@ module RSpec::SleepingKingStudios
         end # if
       end # tap
     end # method examples
+
+    # Get or set the configuration options for
+    # RSpec::SleepingKingStudios::Matchers.
+    def matchers &block
+      (@matchers ||= RSpec::SleepingKingStudios::Configuration::Matchers.new).tap do |config|
+        if block_given?
+          config.instance_eval &block
+        end # if
+      end # tap
+    end # method matchers
   end # class
 end # module