rspec-change_to_now 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e18de5f1c633f028730dd7600213ac9aa54f21
-  data.tar.gz: 169e4f56eb8ace773989ca34e3a6bd101fd3b5bf
+  metadata.gz: 4eeffda32467a4dac65939c732f0f24e05343929
+  data.tar.gz: eff76f6f8b2df43792b0002901c4d9b01573208a
 SHA512:
-  metadata.gz: 9d2aa3673096f3e9c1d5df8ecf08f1e27aa9661265be953b56d12eedbd1d154235166ec55c1c9acef28fa302c37ef5b36ef419d82cd2814113a0dade8d3eaac3
-  data.tar.gz: f3da15d21ad66436057d4aa174546a8450d68825c9d0b145770c99b3ba8226138c2fdff3abe33d986a50be11f3216bdd7c359b4352d4d605fbe820512e5026be
+  metadata.gz: 66ec9926632f994937265a25ba33b030b9c5fdb3efadd0faebce537193ee0f231991c5e02a39ecaadbc913b1a696ebc763ff385b07668e844974e86a1b660ff6
+  data.tar.gz: b7dc9700659f0fec207f1d109c5376e1d6ee9def50e229cec9fd12b7776044b28d6f2afb903e57bb9d8a8a843f40fac28a9a4f56e6e0f87a6df44d543ef4358e

data/Changelog.md

@@ -1,3 +1,10 @@
+### 1.2.0
+
+* Make it easy to include `negate` and `matcher_only` matchers.
+* Move `RSpec::Matchers::ChangeToNow.override_to` setting to `RSpec::ChangeToNow.override_to`
+* When passed both arguments and a block, `detect` will raise a `SyntaxError` instead of `ExpectationNotMet`
+* When passed an object that is not a matcher, `to_now` will behave like `to`, albeit reporting precondition failures.
+
 ### 1.1.0
 
 * Add `with_final_result` matcher that doesn't do precondition test

data/README.md

@@ -4,37 +4,39 @@ RSpec::ChangeTo adds the `to_now` and `not_to_now` methods to `change` matcher t
 
 ## Usage
 
-Use the `to_now` and `not_to_now` (or `not_to`, for short) methods to make assertions about the effect of an rspec `change` block:
+Use the `to_now` and `not_to_now` (or `not_to`, for short) methods to make assertions about the effect of an rspec `change` block rather than just the final state:
 
 ```ruby
-    expect { @x = 1 }.to change { @x }.to_now eq 1
+    expect { @x -= [1] }.to change { @x }.not_to include 1
 ```
 
-or
+Conversely, an example like this, which passes on rspec 3.0, would fail:
 
 ```ruby
-    expect { @x = 1 }.to change { @x }.not_to eq 2
+@x = [1]  
+expect { @x << 1 }.to change { @x }.to_now include 1
 ```
 
-The method `to_now` will check both that the matcher *does not* match prior to the change and that it *does* match after the change.  The method `not_to_now` (`not_to` for short) will do the opposite, ensuring that the matcher matches prior to the change, and fails only after the change.  All methods will ensure that a change actually takes place. 
-
 Also supported are aliases for those who don't want to split their infinitives and for those who would like to differently split them:
 
 * `to_now` can also be called as `now_to`
 * `not_to_now` can also be called `not_to`, `to_not`, `to_not_now` and `not_now_to` 
 
-## Overriding default RSpec behavior
+## How *exactly* does it work?
+
+The method `to_now` will check both that the expected value *does not* match prior to the change and that it *does* match after the change.  The method `not_to_now` (`not_to` for short) will do the opposite, ensuring that the expected value does matche prior to the change, and fails only after the change.  Both methods will ensure that a change actually takes place.
+
+## Globally overriding default RSpec behavior for `to` with `to_now`
 
 You can force the rspec `change` matcher to always use `to_now` instead of `to` by setting:
 
 ```ruby
-RSpec::Matchers::ChangeToNow.override_to = true
+RSpec::ChangeToNow.override_to = true
 ```
 
-
 ## Testing without preconditions
 
-There are a couple of ways to prevent precondition checks if you don't want them for a particular expectation:
+While I'd assert that in most conditions, the automatic precondition checks introduced by `to_now` would be helpful, you may find yourself wanting to disable them for some expectations.  Here are a couple of ways to prevent precondition checks:
 
 1. Use `with_final_result` instead of `to_now` to check your results.  e.g.
 
@@ -76,7 +78,7 @@ And require it as:
 
 ## Why is this useful?
 
-`change { }.from().to()` adds expectation of pre- and post-conditions for a change, but it is restricted only to object values.  With `to_now`, you can write
+When passed object values as expectations, `change { }.from().to()` fails as if it has pre- and post-condition checks.  However, when a passed matcher to `to`, it will not check the inverse condition prior to the change.  With `to_now`, you can write:
 
 ```ruby
     list = []
@@ -99,50 +101,91 @@ While that may not seem like a big deal, the real values comes in more complex s
 
 Arguably, I should be injecting some dependencies here instead of relying on globals, but Rails code doesn't always look like that.  I'm looking forward to playing around with this and seeing if it really helps simplify specs.  I'd love to hear your feedback.
 
-## Additional Matchers Provided
+Finally, *change_to_now* causes inferred pre-condition tests, to be explicitly reported.  For example,
 
-This gem also provides some additional matchers as detailed below.
+```ruby
+number = 2
+expect {
+  number += 1
+}.to change { number }.to_now 2
+```
 
-### `negate(&block)`
+will report:
+ 
+    expected result to have initially passed ~(match 2), but was 2
+    
+If set up *change_to_now* to_now to globally override `change {}. to`, then even `to` will report this way.
 
-This gem also introduces the `negate` matcher, which negates an existing matcher.  You can use it like so:
+## Additional Matchers Provided: *negate*, *detect*, *matcher_only* and *as_matcher*  
 
+This gem also provides some additional matchers as detailed below.  Only the `detect` matcher is automatically added to the rspec DSL when `rspec/change_to_now` is required.  To get the other matchers, add this line to your `spec_helper.rb`:
 
 ```ruby
-    expect(1).to negate(ne(1))
+# spec_helper.rb
+RSpec.configure { |c|.include RSpec::ChangeToNow::Matchers::DSL }
 ```
 
-While it doesn't read every well, it serves an internal purpose, allowing a very simple implementation of `to_now` using composable matcher inputs to the `from` and `to` methods as [added in rspec 3.0](http://myronmars.to/n/dev-blog/2014/01/new-in-rspec-3-composable-matchers).
+* `negate(&block)` *(optional)*
 
-### `detect(&block)`
+    This gem also introduces the `negate` matcher, which negates an existing matcher.  You can use it like so:
 
-This gem also adds the `detect` matcher, which behaves like the `include` matcher when passed a `satisfy` matcher created using the given block.  You can use it like so:
 
+    ```ruby
+        expect(1).to negate(ne(1))
+    ```
+    
+    While it doesn't read every well, it serves an internal purpose, allowing a very simple implementation of `to_now` using composable matcher inputs to the `from` and `to` methods as [added in rspec 3.0](http://myronmars.to/n/dev-blog/2014/01/new-in-rspec-3-composable-matchers).
+    
+* `detect(&block)`
 
-```ruby
-    list = []
-    expect { list << 2 }.to change { list }.to detect(&:even?)
-```
+    The `detect` matcher behaves like the `include` matcher when passed a `satisfy` matcher created using the given block.  You can use it like so:
+    
+    ```ruby
+        list = []
+        expect { list << 2 }.to change { list }.to detect(&:even?)
+    ```
+    
+    This is the same as:
+    
+    ```ruby
+        list = []
+        expect { list << 2 }.to change { list }.to include satisfy(&:even?)
+    ```
+    
+    A more interesting use might be:
+    
+    ```ruby
+        person = Person.create(name: 'Taylor')
+        expect { person.siblings.create(name: 'Sam') }.to change {
+          Person.all
+        }.to_now detect { |person|
+          person.name == 'Taylor'
+        }
+    ```
 
-This is the same as:
+    `detect` behaves exactly like `include` when it is not passed a block and will raise an exception if passed both expected items/matchers and a block.
 
-```ruby
-    list = []
-    expect { list << 2 }.to change { list }.to include satisfy(&:even?)
-```
+* `matcher_only(matcher)` *(optional)*
 
-A more interesting use might be:
+    The `match_only` matcher just passes the given matcher through unless it is not a matcher, in which case it raises a syntax error.  While this would pass:
 
-```ruby
-    person = Person.create(name: 'Taylor')
-    expect { person.siblings.create(name: 'Sam') }.to change {
-      Person.all
-    }.to_now detect { |person|
-      person.name == 'Taylor'
-    }
-```
+    ```ruby
+        expect(1).to matcher_only(eq(1))
+    ```
+    
+    this would fail with a syntax error:
+    
+    ```ruby
+        expect(1).to matcher_only(1)
+    ```
+    
+* `as_matcher(expected)` *(optional)*
 
-`detect` behaves exactly like `include` when it is not passed a block and will raise an exception if passed both expected items/matchers and a block.
+    The `as_matcher` matcher just passes the given matcher through unless it is not a matcher, in which case it returns a new matcher created using `match(expected)`.  So, for example, this would work:
+    
+    ```ruby
+        expect(1).to as_matcher(1)
+    ```
 
 ## Contributing
 

data/features/change_to_now.feature

@@ -46,7 +46,7 @@ Feature: expecting a matcher to change
   Scenario: overriding RSpec `change { }.to` to behave like `change { }.to_now`
     Given a file named "example_spec.rb" with:
       """ruby
-        RSpec::Matchers::ChangeToNow.override_to = true
+        RSpec::ChangeToNow.override_to = true
 
         describe "adding one" do
           it "adds one" do

data/features/matcher_only.feature

@@ -0,0 +1,30 @@
+Feature: matcher-only matcher
+
+  Scenario: when the argument is a matcher
+    Given a file named "example_spec.rb" with:
+    """ruby
+        include RSpec::ChangeToNow::Matchers::DSL
+
+        describe "when passed a matcher" do
+          it "just passes the matcher through" do
+            expect(2).to matcher_only(eq 2)
+          end
+        end
+      """
+    When I run rspec
+    Then the examples should all pass
+
+  Scenario: when the argument is not a matcher
+    Given a file named "example_spec.rb" with:
+    """ruby
+        include RSpec::ChangeToNow::Matchers::DSL
+
+        describe "when passed a non-matcher object" do
+          it "reports a syntax error" do
+            expect(2).to matcher_only(2)
+          end
+        end
+      """
+    When I run rspec
+    Then the output should contain "SyntaxError"
+    And the output should contain "expected a matcher as an argument but got: 2"

data/features/negate.feature

@@ -3,6 +3,7 @@ Feature: negating a matcher
   Scenario: when the matcher is negated
     Given a file named "example_spec.rb" with:
     """ruby
+        include RSpec::ChangeToNow::Matchers::DSL
 
         describe "testing equality" do
           it "is the same as negated inequality" do
@@ -16,6 +17,7 @@ Feature: negating a matcher
   Scenario: failures are correctly reported
     Given a file named "example_spec.rb" with:
     """ruby
+        include RSpec::ChangeToNow::Matchers::DSL
 
         describe "testing equality" do
           it "fails if the the negated matcher does match" do

data/lib/rspec/change_to_now/matchers/as_matcher.rb

@@ -0,0 +1,18 @@
+require 'rspec/core'
+require 'rspec/expectations'
+
+module RSpec
+  module ChangeToNow::Matchers
+    # Decorator that wraps a matcher and raises a syntax error if the matcher is not a matcher.
+    #
+    # @api private
+    class AsMatcher < RSpec::Matchers::MatcherDelegator
+      include RSpec::Matchers::Composable
+
+      def initialize(expected)
+        expected = RSpec::Matchers::BuiltIn::Match.new(expected) unless RSpec::Matchers.is_a_matcher?(expected)
+        super(expected)
+      end
+    end
+  end
+end

data/lib/rspec/change_to_now/{detect.rb → matchers/detect.rb}

@@ -1,12 +1,12 @@
 require 'rspec/core'
 require 'rspec/expectations'
 
-module RSpec
+module RSpec::ChangeToNow
   module Matchers
     # @api private
     # Provides the implementation for `detect`.
     # Not intended to be instantiated directly.
-    class Detect < BuiltIn::Include
+    class Detect < RSpec::Matchers::BuiltIn::Include
       def initialize(*expected, &block)
         if @block = block
           block_matcher = RSpec::Matchers::BuiltIn::Satisfy.new(&block)
@@ -70,7 +70,7 @@ module RSpec
       end
 
       def handle_arguments_for_match(actual)
-        return false if has_both_block_and_arguments?
+        raise SyntaxError, block_and_arguments_together_failure_message if has_both_block_and_arguments?
         original_actual = actual
         actual = actual.to_a if @block && actual.is_a?(Hash)
         value = yield(actual)
@@ -78,17 +78,5 @@ module RSpec
         value
       end
     end
-
-    # If given a block, passes if the block returns a truthy value for any of the actual items or for the key-value pair is the actual item list is a hash.
-    # Without a block, it behaves identically to +include+.
-    # +expected+ must be empty if a block is provided.
-    #
-    # @example
-    #   expect([2]).to detect(&:even?)
-    #   expect({a: 2}).to detect { |k,v| v.even? }
-    #   expect([1]).to detect 1
-    def detect(*expected, &block)
-      Detect.new(*expected, &block)
-    end
   end
 end

data/lib/rspec/change_to_now/matchers/dsl.rb

@@ -0,0 +1,36 @@
+module RSpec::ChangeToNow::Matchers::DSL
+  # @api public
+  # Returns a new matcher that fails with a syntax error if +matcher+ is not a matcher but otherwise behaves just like +matcher+.
+  def matcher_only(matcher)
+    RSpec::ChangeToNow::Matchers::MatcherOnly.new(matcher)
+  end
+
+  # @api public
+  # Returns a matcher that behaves like the inverse of +matcher+.
+  def negate(matcher)
+    RSpec::ChangeToNow::Matchers::Negate.new(matcher)
+  end
+
+  # @api public
+  # Returns a matcher that behaves like the +matcher+ if passed a matcher, otherwise like match(+matcher+)
+  def as_matcher(expected)
+    RSpec::ChangeToNow::Matchers::AsMatcher.new(expected)
+  end
+
+  module Detect
+    # @api public
+    # If given a block, passes if the block returns a truthy value for any of the actual items or for the key-value pair is the actual item list is a hash.
+    # Without a block, it behaves identically to +include+.
+    # +expected+ must be empty if a block is provided.
+    #
+    # @example
+    #   expect([2]).to detect(&:even?)
+    #   expect({a: 2}).to detect { |k,v| v.even? }
+    #   expect([1]).to detect 1
+    def detect(*expected, &block)
+      RSpec::ChangeToNow::Matchers::Detect.new(*expected, &block)
+    end
+  end
+
+  include Detect
+end

data/lib/rspec/change_to_now/{verify_argument_is_matcher.rb → matchers/matcher_only.rb}

@@ -2,14 +2,14 @@ require 'rspec/core'
 require 'rspec/expectations'
 
 module RSpec
-  module Matchers
-    # Decorator that wraps a matcher and raises an error if the matcher is not a matcher.
+  module ChangeToNow::Matchers
+    # Decorator that wraps a matcher and raises a syntax error if the matcher is not a matcher.
     #
     # @api private
-    class VerifyArgumentIsMatcher < MatcherDelegator
+    class MatcherOnly < RSpec::Matchers::MatcherDelegator
       # Forward messages on to the wrapped matcher, first verifying that this really is a matcher.
       def method_missing(method, *args)
-        raise SyntaxError, "expects a matcher as an argument but got: #{base_matcher.inspect}" unless Matchers.is_a_matcher?(base_matcher)
+        raise SyntaxError, "expected a matcher as an argument but got: #{base_matcher.inspect}" unless Matchers.is_a_matcher?(base_matcher)
         base_matcher.send(method, *args)
       end
 

data/lib/rspec/change_to_now/{negate.rb → matchers/negate.rb}

@@ -2,13 +2,13 @@ require 'rspec/core'
 require 'rspec/expectations'
 
 module RSpec
-  module Matchers
+  module ChangeToNow::Matchers
     # @api private
     # Provides the implementation for `negate`.
     # Not intended to be instantiated directly.
     class Negate
-      include Composable
-      include Pretty
+      include RSpec::Matchers::Composable
+      include RSpec::Matchers::Pretty
 
       def initialize(matcher)
         @matcher = matcher
@@ -58,14 +58,5 @@ module RSpec
         @matcher.supports_block_expectations?
       end
     end
-
-    # Passes if provided +matcher+ fails and vice-versa.
-    #
-    # @example
-    #   expect([1]).to negate(eq(2))
-    #   expect([1]).not_to negate(eq(1))
-    def negate(matcher)
-      Negate.new(matcher)
-    end
   end
 end

data/lib/rspec/change_to_now/matchers.rb

@@ -0,0 +1,6 @@
+require 'rspec/change_to_now/matchers/detect'
+require 'rspec/change_to_now/matchers/negate'
+require 'rspec/change_to_now/matchers/matcher_only'
+require 'rspec/change_to_now/matchers/as_matcher'
+require 'rspec/change_to_now/matchers/dsl'
+

data/lib/rspec/change_to_now/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module ChangeToNow
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/rspec/change_to_now.rb

@@ -1,115 +1,103 @@
 require 'rspec/change_to_now/version'
-require 'rspec/change_to_now/detect'
-require 'rspec/change_to_now/negate'
-require 'rspec/change_to_now/verify_argument_is_matcher'
+require 'rspec/change_to_now/matchers'
 require 'rspec/core'
 require 'rspec/expectations'
 
-module RSpec::Matchers
-  module ChangeToNowMatchers
-    private
-
-    # @private
-    def negate(matcher)
-      RSpec::Matchers::Negate.new(matcher)
-    end
+module RSpec
+  module Matchers::BuiltIn
+    class Change
+      include RSpec::ChangeToNow::Matchers::DSL
+
+      # @api public
+      # Passes if +matcher+ fails on the result of the change block before the expectation block and passes after.
+      #
+      # @example
+      #   expect({ @x = 1 }.to change { @x }.to_now eq 1
+      #
+      # In implementation, this is identical to
+      #   change {}.to eq { }`
+      # is the same as
+      #   change {}.to_now eq(1)
+      #   change {}.from(negate(eq(1))).to(eq(1))
+      def to_now(matcher)
+        RSpec::Matchers::BuiltIn::ChangeToValue.new(@change_details, as_matcher(matcher)).
+          from(negate(as_matcher(matcher)))
+      end
 
-    # @private
-    def verify_argument_is_matcher(matcher)
-      RSpec::Matchers::VerifyArgumentIsMatcher.new(matcher)
-    end
-  end
+      # @api public
+      # Passes if +matcher+ passes on the result of the change block before the expectation block and fails after.
+      #
+      # @example
+      #   expect({ @x = 1 }.to change { @x }.not_to_now eq 1
+      def not_to_now(matcher)
+        RSpec::Matchers::BuiltIn::ChangeToValue.new(@change_details, negate(as_matcher(matcher))).
+          from(as_matcher(matcher))
+      end
 
-  class BuiltIn::Change
-    include ChangeToNowMatchers
-
-    # @api public
-    # Passes if +matcher+ fails on the result of the change block before the expectation block and passes after.
-    #
-    # @example
-    #   expect({ @x = 1 }.to change { @x }.to_now eq 1
-    #
-    # In implementation, this is identical to
-    #   change {}.to eq { }`
-    # is the same as
-    #   change {}.to_now eq(1)
-    #   change {}.from(negate(eq(1))).to(eq(1))
-    def to_now(matcher)
-      RSpec::Matchers::BuiltIn::ChangeToValue.new(@change_details, verify_argument_is_matcher(matcher)).
-        from(negate(verify_argument_is_matcher(matcher)))
-    end
+      # @api public
+      alias_method :now_to, :to_now
 
-    # @api public
-    # Passes if +matcher+ passes on the result of the change block before the expectation block and fails after.
-    #
-    # @example
-    #   expect({ @x = 1 }.to change { @x }.not_to_now eq 1
-    def not_to_now(matcher)
-      RSpec::Matchers::BuiltIn::ChangeToValue.new(@change_details, negate(verify_argument_is_matcher(matcher))).
-        from(verify_argument_is_matcher(matcher))
-    end
+      # @api public
+      alias_method :not_to, :not_to_now
 
-    # @api public
-    alias_method :now_to, :to_now
+      # @api public
+      alias_method :not_now_to, :not_to_now
 
-    # @api public
-    alias_method :not_to, :not_to_now
+      # @api public
+      alias_method :to_not, :not_to_now
 
-    # @api public
-    alias_method :not_now_to, :not_to_now
+      # @api public
+      alias_method :to_not_now, :not_to_now
 
-    # @api public
-    alias_method :to_not, :not_to_now
+      # @private
+      alias_method :to_without_to_now, :to
 
-    # @api public
-    alias_method :to_not_now, :not_to_now
+      # @private
+      def to_with_to_now(expected)
+        if RSpec::ChangeToNow.override_to && RSpec::Matchers.is_a_matcher?(expected)
+          to_now(expected)
+        else
+          to_without_to_now(expected)
+        end
+      end
 
-    # @private
-    alias_method :to_without_to_now, :to
+      # @private
+      alias_method :to, :to_with_to_now
 
-    # @private
-    def to_with_to_now(expected)
-      if RSpec::Matchers::ChangeToNow.override_to && RSpec::Matchers.is_a_matcher?(expected)
-        to_now(expected)
-      else
+      # @api public
+      def with_final_result(expected)
         to_without_to_now(expected)
       end
     end
 
-    # @private
-    alias_method :to, :to_with_to_now
-
-    # @api public
-    def with_final_result(expected)
-      to_without_to_now(expected)
-    end
-  end
-
-  class BuiltIn::ChangeFromValue
-    include ChangeToNowMatchers
+    class ChangeFromValue
+      include RSpec::ChangeToNow::Matchers::DSL
 
-    def to_now(matcher)
-      RSpec::Matchers::BuiltIn::ChangeToValue.new(
-        @change_details,
-        verify_argument_is_matcher(matcher)
-      ).from(@expected_before)
-    end
+      def to_now(matcher)
+        RSpec::Matchers::BuiltIn::ChangeToValue.new(
+          @change_details,
+          matcher_only(matcher)
+        ).from(@expected_before)
+      end
 
-    def not_to_now(matcher)
-      RSpec::Matchers::BuiltIn::ChangeToValue.new(
-        @change_details,
-        negate(verify_argument_is_matcher(matcher))
-      ).from(@expected_before)
-    end
+      def not_to_now(matcher)
+        RSpec::Matchers::BuiltIn::ChangeToValue.new(
+          @change_details,
+          negate(matcher_only(matcher))
+        ).from(@expected_before)
+      end
 
-    def with_final_result(expected)
-      to_without_to_now(expected)
+      def with_final_result(expected)
+        to_without_to_now(expected)
+      end
     end
   end
 
-  class ChangeToNow
+  module ChangeToNow
     class << self
       attr_accessor :override_to
     end
   end
 end
+
+RSpec.configure { |c| c.include RSpec::ChangeToNow::Matchers::DSL::Detect } if RSpec.respond_to?(:configure)

data/spec/rspec/change_to_now_spec.rb

@@ -37,13 +37,13 @@ module RSpec
           }.to change { number }.to_now eq 2
         }.to fail_matching("expected result to have initially been ~(eq 2), but was 2")
       end
-      it "raises an error when not passed a matcher" do
-        number = 1
+      it "reports an error about the precondition if passed a non-matcher object" do
+        number = 2
         expect {
           expect {
             number += 1
-          }.to change { }.to_now 2
-        }.to raise_error SyntaxError, /expects a matcher as an argument/
+          }.to change { number }.to_now 2
+        }.to fail_matching("expected result to have initially been ~(match 2), but was 2")
       end
 
       describe "after #from" do
@@ -112,13 +112,13 @@ module RSpec
           }.to change { number }.not_to_now satisfy(&:even?)
         }.to fail_matching("expected result to have changed to ~(satisfy block), but is now 4")
       end
-      it "raises an error when not passed a matcher" do
+      it "reports an error about the precondition if passed a non-matcher object" do
         number = 1
         expect {
           expect {
             number += 1
           }.to change { }.not_to_now 2
-        }.to raise_error SyntaxError, /expects a matcher as an argument/
+        }.to fail_matching("expected result to have initially been match 2, but was nil")
       end
 
       describe "after #from" do
@@ -224,7 +224,7 @@ module RSpec
 
     describe "when #to has been overridden by the configuration setting" do
       before do
-        allow(RSpec::Matchers::ChangeToNow).to receive(:override_to).and_return(true)
+        allow(RSpec::ChangeToNow).to receive(:override_to).and_return(true)
       end
 
       it "fails when the final expectation is already met" do

data/spec/rspec/matchers/as_matcher_spec.rb

@@ -0,0 +1,19 @@
+require_relative 'spec_helper'
+
+describe "as_matcher" do
+  describe "when the argument is a matcher" do
+    it "delegates to the matcher" do
+      expect {
+        expect(1).to as_matcher(eq 2)
+      }.to fail_matching(/expected: 2.*got: 1/m)
+    end
+  end
+
+  describe "when the argument is not a matcher" do
+    it "uses the default matcher" do
+      expect {
+        expect(1).to as_matcher(2)
+      }.to fail_matching(/expected 1 to match 2/m)
+    end
+  end
+end

data/spec/rspec/{detect_spec.rb → matchers/detect_spec.rb}

@@ -1,6 +1,6 @@
-require_relative '../spec_helper'
+require_relative 'spec_helper'
 
-RSpec.describe "#detect matcher" do
+describe "detect" do
   describe "expect(...).to detect(&with_block)" do
     context "for an array target" do
       it "passes if target detects expected" do
@@ -57,7 +57,7 @@ RSpec.describe "#detect matcher" do
     it "fails with a message" do
       expect {
         expect([0, 1]).to detect(0) { true }
-      }.to fail_matching(%Q{can take arguments or a block but not both})
+      }.to raise_error SyntaxError, "detect can take arguments or a block but not both"
     end
   end
 
@@ -65,7 +65,7 @@ RSpec.describe "#detect matcher" do
     it "fails with a message" do
       expect {
         expect([0, 1]).not_to detect(0) { true }
-      }.to fail_matching(%Q{can take arguments or a block but not both})
+      }.to raise_error SyntaxError, "detect can take arguments or a block but not both"
     end
   end
 end

data/spec/rspec/{verify_argument_is_matcher_spec.rb → matchers/matcher_only_spec.rb}

@@ -1,10 +1,10 @@
-require_relative '../spec_helper'
+require_relative 'spec_helper'
 
-describe RSpec::Matchers::VerifyArgumentIsMatcher do
+describe "matcher_only" do
   describe "when the argument is a matcher" do
     it "delegates to the matcher" do
       expect {
-        expect(1).to RSpec::Matchers::VerifyArgumentIsMatcher.new(eq 2)
+        expect(1).to matcher_only(eq 2)
       }.to fail_matching(/expected: 2.*got: 1/m)
     end
   end
@@ -12,8 +12,8 @@ describe RSpec::Matchers::VerifyArgumentIsMatcher do
   describe "when the argument is not a matcher" do
     it "raises a syntax error when the matcher is evaluated" do
       expect {
-        expect(1).to RSpec::Matchers::VerifyArgumentIsMatcher.new(2)
-      }.to raise_error SyntaxError, "expects a matcher as an argument but got: 2"
+        expect(1).to matcher_only(2)
+      }.to raise_error SyntaxError, "expected a matcher as an argument but got: 2"
     end
   end
 end

data/spec/rspec/{negate_spec.rb → matchers/negate_spec.rb}

@@ -1,6 +1,6 @@
-require_relative '../spec_helper'
+require_relative 'spec_helper'
 
-RSpec.describe RSpec::Matchers::Negate do
+describe "negate" do
   describe "with literal expectations" do
     describe "when not negated" do
       describe "when the original matcher provides :does_not_match?" do

data/spec/rspec/matchers/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../../spec_helper'

data/spec/spec_helper.rb

@@ -17,4 +17,5 @@ end
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.order = 'random'
+  config.include RSpec::ChangeToNow::Matchers::DSL
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-change_to_now
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrew S. Brown
@@ -169,20 +169,26 @@ files:
 - cucumber.yml
 - features/change_to_now.feature
 - features/detect.feature
+- features/matcher_only.feature
 - features/negate.feature
 - features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
 - lib/rspec/change_to_now.rb
-- lib/rspec/change_to_now/detect.rb
-- lib/rspec/change_to_now/negate.rb
-- lib/rspec/change_to_now/verify_argument_is_matcher.rb
+- lib/rspec/change_to_now/matchers.rb
+- lib/rspec/change_to_now/matchers/as_matcher.rb
+- lib/rspec/change_to_now/matchers/detect.rb
+- lib/rspec/change_to_now/matchers/dsl.rb
+- lib/rspec/change_to_now/matchers/matcher_only.rb
+- lib/rspec/change_to_now/matchers/negate.rb
 - lib/rspec/change_to_now/version.rb
 - rspec-change_to_now.gemspec
 - script/test_all
 - spec/rspec/change_to_now_spec.rb
-- spec/rspec/detect_spec.rb
-- spec/rspec/negate_spec.rb
-- spec/rspec/verify_argument_is_matcher_spec.rb
+- spec/rspec/matchers/as_matcher_spec.rb
+- spec/rspec/matchers/detect_spec.rb
+- spec/rspec/matchers/matcher_only_spec.rb
+- spec/rspec/matchers/negate_spec.rb
+- spec/rspec/matchers/spec_helper.rb
 - spec/spec_helper.rb
 - spec/support/matchers.rb
 homepage: https://github.com/dontfidget/rspec-change_to_now
@@ -212,13 +218,16 @@ summary: Provides "change_to_now" method formally part of rspec-core
 test_files:
 - features/change_to_now.feature
 - features/detect.feature
+- features/matcher_only.feature
 - features/negate.feature
 - features/step_definitions/additional_cli_steps.rb
 - features/support/env.rb
 - spec/rspec/change_to_now_spec.rb
-- spec/rspec/detect_spec.rb
-- spec/rspec/negate_spec.rb
-- spec/rspec/verify_argument_is_matcher_spec.rb
+- spec/rspec/matchers/as_matcher_spec.rb
+- spec/rspec/matchers/detect_spec.rb
+- spec/rspec/matchers/matcher_only_spec.rb
+- spec/rspec/matchers/negate_spec.rb
+- spec/rspec/matchers/spec_helper.rb
 - spec/spec_helper.rb
 - spec/support/matchers.rb
 has_rdoc: