rspec-mocks 3.0.0 → 3.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NGVjNjIxMDkzYzYzOGM1NTJlY2NlNmU4NDU4MzFiMDg5ZDkwODRmZA==
-  data.tar.gz: !binary |-
-    MmY5NWExM2FkYmFlNWQxOWU3ZmZiZjQzYmY2ZTI1MjRmNjNlYWZhMA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MzhiNTZkYzg1ZjZhN2Y2NGU3ZTRkOGQwNWNiZmUzNzc0NzEyODZmN2UxMjY5
-    NmYwODNhZGNiNGZmNWM5YzBkYzY5NDU4YWRiZTFhODhiNTVmMTVjNjNjNDA4
-    ODVjZjRjNTQzNGUwOWM1Y2NiMTY1MDdjYWUxMmNmMDc3NWQwZmI=
-  data.tar.gz: !binary |-
-    NDQ0MDBhZDE0NzkyNzRjODFjNmZiOWExNzU3NWJmZjU4ZTFhMzAyYzlkNTk0
-    ZDIxNjZhODk0ODI2MjY1OTFkNTljYTk0N2ZkMDBhNTcwNTk5MTc1Yzg1MDhj
-    ZTczN2Q2M2I3YjgxNTg4YzhiM2FmMzliZGNiM2MxNTE4OTJhYjE=
+SHA1:
+  metadata.gz: 16d5f671e68051be014fb930e9980f5a0c19d5ee
+  data.tar.gz: b035e939d0afc695e7b03485f1edc2356c5b0bc0
+SHA512:
+  metadata.gz: 46ba65b5222400961866c699044adba07374c0a2c241e2f011e2eb55b8fdfc3c167db0f371a925a06704ac6d209e1400a1802c45d94ea25ae38142bcf396c9bc
+  data.tar.gz: 617ae574ebe247f7b2ee1c6a45a94fb200006b56dd8c98ec536d655622a85749e0a10985e491e47709a744ebc450d494d591b5367c91bd89cc3f0001e6f95c9b

data/Changelog.md

@@ -1,3 +1,71 @@
+### 3.1.0 / 2014-09-04
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.4...v3.1.0)
+
+Enhancements:
+
+* Add spying methods (`spy`, `ìnstance_spy`, `class_spy` and `object_spy`)
+  which create doubles as null objects for use with spying in testing. (Sam
+  Phippen, #671)
+* `have_received` matcher will raise "does not implement" errors correctly when
+  used with verifying doubles and partial doubles. (Xavier Shay, #722)
+* Allow matchers to be used in place of keyword arguments in `with`
+  expectations. (Xavier Shay, #726)
+* Add `thrice` modifier to message expectation interface as a synonym
+  for `exactly(3).times`. (Dennis Taylor, #753)
+* Add more `thrice` synonyms e.g. `.at_least(:thrice)`, `.at_most(:thrice)`,
+  `receive(...).thrice` and `have_received(...).thrice`. (Jon Rowe, #754)
+* Add `and_wrap_original` modifier for partial doubles to mutate the
+  response from a method. (Jon Rowe, #762)
+
+Bugfixes:
+
+* Remove `any_number_of_times` from `any_instance` recorders that were
+  erroneously causing mention of the method in documentation. (Jon Rowe, #760)
+* Prevent included modules being detected as prepended modules on Ruby 2.0.
+  (Eugene Kenny, #771)
+
+### 3.0.4 / 2014-08-14
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.3...v3.0.4)
+
+Bug Fixes:
+
+* Restore `kind_of(x)` to match using `arg.kind_of?(x)` (like RSpec 2)
+  rather than `x === arg`. (Jon Rowe, #750)
+
+### 3.0.3 / 2014-07-21
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.2...v3.0.3)
+
+Bug Fixes:
+
+* `have_received` matcher will raise "does not implement" errors correctly when
+  used with verifying doubles and partial doubles. (Xavier Shay, #722)
+* Make `double.as_null_object.dup` and `double.as_null_object.clone`
+  make the copies be null objects. (Myron Marston, #732)
+* Don't inadvertently define `BasicObject` in 1.8.7. (Chris Griego, #739)
+
+### 3.0.2 / 2014-06-19
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.1...v3.0.2)
+
+Bug Fixes:
+
+* Fix edge case that triggered "can't add a new key into hash during
+  iteration" during mock verification. (Sam Phippen, Myron Marston, #711)
+* Fix verifying doubles so that when they accidentally leak into another
+  example, they provide the same clear error message that normal doubles
+  do. (Myron Marston, #718)
+* Make `ordered` work with exact receive counts. (Sam Phippen, #713)
+
+### 3.0.1 / 2014-06-07
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.0...v3.0.1)
+
+Bug Fixes:
+
+* Fix `receive_message_chain(...)` so that it supports `with` just like
+  `stub_chain` did. (Jon Rowe, #697)
+* Fix regression in `expect_any_instance_of` so that it expects the
+  message on _any_ instance rather than on _every_ instance.
+  (Myron Marston, #699)
+
 ### 3.0.0 / 2014-06-01
 [Full Changelog](http://github.com/rspec/rspec-mocks/compare/v3.0.0.rc1...v3.0.0)
 
@@ -141,7 +209,7 @@ Bug Fixes:
   behavior. (Maurício Linhares)
 
 ### 3.0.0.beta1 / 2013-11-07
-[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.0...v3.0.0.beta1)
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.2...v3.0.0.beta1)
 
 Breaking Changes for 3.0.0:
 
@@ -204,6 +272,26 @@ Bug Fixes:
   returns `nil` or `''` so that you still get a useful message.
   (Nick DeLuca)
 
+### 2.99.2 / 2014-07-21
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.1...v2.99.2)
+
+Enhancements:
+
+* Warn about upcoming change to `#===` matching and `DateTime#===` behaviour.
+  (Jon Rowe, #735)
+
+### 2.99.1 / 2014-06-12
+[Full Changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.0...v2.99.1)
+
+Bug Fixes:
+
+* Fix bug that caused errors at the end of each example
+  when a `double.as_null_object` had been frozen. (Yuji Nakayama, #698)
+
+Deprecations:
+
+* Deprecate freezing a test double. (Yuji Nakayama, #698)
+
 ### 2.99.0 / 2014-06-01
 [Full Changelog](http://github.com/rspec/rspec-mocks/compare/v2.99.0.rc1...v2.99.0)
 

data/README.md

@@ -1,5 +1,4 @@
-# RSpec Mocks [![Build Status](https://secure.travis-ci.org/rspec/rspec-mocks.png?branch=master)](http://travis-ci.org/rspec/rspec-mocks) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.png)](https://codeclimate.com/github/rspec/rspec-mocks) [![Inline docs](http://inch-pages.github.io/github/rspec/rspec-mocks.png)](http://inch-pages.github.io/github/rspec/rspec-mocks)
-
+# RSpec Mocks [![Build Status](https://secure.travis-ci.org/rspec/rspec-mocks.png?branch=master)](http://travis-ci.org/rspec/rspec-mocks) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.png)](https://codeclimate.com/github/rspec/rspec-mocks)
 rspec-mocks is a test-double framework for rspec with support for method stubs,
 fakes, and message expectations on generated test-doubles and real objects
 alike.
@@ -102,24 +101,38 @@ zipcode.valid?
 
 ## Test Spies
 
-Verifies the given object received the expected message during the course of the
-test. The method must have previously been stubbed in order for messages to be
-verified.
+Verifies the given object received the expected message during the course of
+the test. For a message to be verified, the given object must be setup to spy
+on it, either by having it explicitly stubbed or by being a null object double
+(e.g. `double(...).as_null_object`). Convenience methods are provided to easily
+create null object doubles for this purpose:
+
+```ruby
+spy("invitation") # => same as `double("invitation").as_null_object`
+instance_spy("Invitation") # => same as `instance_double("Invitation").as_null_object`
+class_spy("Invitation") # => same as `class_double("Invitation").as_null_object`
+object_spy("Invitation") # => same as `object_double("Invitation").as_null_object`
+```
 
 Stubbing and verifying messages received in this way implements the Test Spy
 pattern.
 
 ```ruby
-  invitation = double('invitation', :accept => true)
+invitation = spy('invitation')
+
+user.accept_invitation(invitation)
 
-  user.accept_invitation(invitation)
+expect(invitation).to have_received(:accept)
 
-  expect(invitation).to have_received(:accept)
+# You can also use other common message expectations. For example:
+expect(invitation).to have_received(:accept).with(mailer)
+expect(invitation).to have_received(:accept).twice
+expect(invitation).to_not have_received(:accept).with(mailer)
 
-  # You can also use other common message expectations. For example:
-  expect(invitation).to have_received(:accept).with(mailer)
-  expect(invitation).to have_received(:accept).twice
-  expect(invitation).to_not have_received(:accept).with(mailer)
+# One can specify a return value on the spy the same way one would a double.
+invitation = spy('invitation', :accept => true)
+expect(invitation).to have_received(:accept).with(mailer)
+expect(invitation.accept).to eq(true)
 ```
 
 ## Nomenclature
@@ -196,8 +209,10 @@ expect(double).to receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can
 expect(double).to receive(:msg).with(1, boolean(), "b") #2nd argument can be true or false
 expect(double).to receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
 expect(double).to receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
-expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b")
-                    #2nd argument can be object that responds to #abs and #div
+expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b") #2nd argument can be object that responds to #abs and #div
+expect(double).to receive(:msg).with(hash_including(:a => 5)) # first arg is a hash with a: 5 as one of the key-values
+expect(double).to receive(:msg).with(array_including(5)) # first arg is an array with 5 as one of the key-values
+expect(double).to receive(:msg).with(hash_excluding(:a => 5)) # first arg is a hash without a: 5 as one of the key-values
 ```
 
 ## Receive Counts
@@ -212,7 +227,6 @@ expect(double).to receive(:msg).at_least(n).times
 expect(double).to receive(:msg).at_most(:once)
 expect(double).to receive(:msg).at_most(:twice)
 expect(double).to receive(:msg).at_most(n).times
-expect(double).to receive(:msg).any_number_of_times
 ```
 
 ## Ordering
@@ -334,7 +348,7 @@ Instead of `before(:context)`, use `before(:example)`.
 
 rspec-mocks provides two methods, `allow_any_instance_of` and
 `expect_any_instance_of`, that will allow you to stub or mock any instance
-of a class. They are used in place for `allow` or `expect`:
+of a class. They are used in place of `allow` or `expect`:
 
 ```ruby
 allow_any_instance_of(Widget).to receive(:name).and_return("Wibble")
@@ -351,8 +365,8 @@ general we discourage its use for a number of reasons:
   feature operates on entire classes of objects. As a result there are some
   sematically confusing edge cases. For example in
   `expect_any_instance_of(Widget).to receive(:name).twice` it isn't clear
-  whether each specific instance is allowed to receive `name` twice, or if two
-  receives total are allowed. (It's the former.)
+  whether each specific instance is expected to receive `name` twice, or if two
+  receives total are expected. (It's the former.)
 * Using this feature is often a design smell. It may be
   that your test is trying to do too much or that the object under test is too
   complex.

data/lib/rspec/mocks/any_instance/chain.rb

@@ -37,7 +37,7 @@ module RSpec
           record :with
           record :once
           record :twice
-          record :any_number_of_times
+          record :thrice
           record :exactly
           record :times
           record :never
@@ -84,7 +84,7 @@ module RSpec
           super
         end
 
-        private
+      private
 
         def negated?
           messages.any? { |(message, *_), _| message == :never }

data/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -4,7 +4,7 @@ module RSpec
       # @private
       class ExpectationChain < Chain
         def expectation_fulfilled?
-          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+          @expectation_fulfilled || constrained_to_any_of?(:never)
         end
 
         def initialize(*args, &block)
@@ -14,13 +14,12 @@ module RSpec
 
       private
 
-        def verify_invocation_order(rspec_method_name, *args, &block)
+        def verify_invocation_order(_rspec_method_name, *_args, &_block)
         end
       end
 
       # @private
       class PositiveExpectationChain < ExpectationChain
-
       private
 
         def create_message_expectation_on(instance)

data/lib/rspec/mocks/any_instance/message_chains.rb

@@ -35,15 +35,13 @@ module RSpec
         # @private
         def each_unfulfilled_expectation_matching(method_name, *args)
           @chains_by_method_name[method_name].each do |chain|
-            if !chain.expectation_fulfilled? && chain.matches_args?(*args)
-              yield chain
-            end
+            yield chain if !chain.expectation_fulfilled? && chain.matches_args?(*args)
           end
         end
 
         # @private
         def all_expectations_fulfilled?
-          @chains_by_method_name.all? do |method_name, chains|
+          @chains_by_method_name.all? do |_method_name, chains|
             chains.all? { |chain| chain.expectation_fulfilled? }
           end
         end
@@ -74,9 +72,12 @@ module RSpec
 
         def raise_if_second_instance_to_receive_message(instance)
           @instance_with_expectation ||= instance if ExpectationChain === instance
-          if ExpectationChain === instance && !@instance_with_expectation.equal?(instance)
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
-          end
+          return unless ExpectationChain === instance
+          return if @instance_with_expectation.equal?(instance)
+
+          raise RSpec::Mocks::MockExpectationError,
+                "Exactly one instance should have received the following " \
+                "message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
         end
       end
     end

data/lib/rspec/mocks/any_instance/proxy.rb

@@ -60,7 +60,11 @@ module RSpec
 
         def should_receive(method_name, &block)
           perform_proxying(__method__, [method_name], block) do |proxy|
-            proxy.add_message_expectation(method_name, &block)
+            # Yeah, this is a bit odd...but if we used `add_message_expectation`
+            # then it would act like `expect_every_instance_of(klass).to receive`.
+            # The any_instance recorder takes care of validating that an instance
+            # received the message.
+            proxy.add_stub(method_name, &block)
           end
         end
 
@@ -93,11 +97,11 @@ module RSpec
         end
 
         if RUBY_VERSION.to_f > 1.8
-          def respond_to_missing?(method_name, include_private = false)
+          def respond_to_missing?(method_name, include_private=false)
             super || @targets.first.respond_to?(method_name, include_private)
           end
         else
-          def respond_to?(method_name, include_private = false)
+          def respond_to?(method_name, include_private=false)
             super || @targets.first.respond_to?(method_name, include_private)
           end
         end

data/lib/rspec/mocks/any_instance/recorder.rb

@@ -15,7 +15,7 @@ module RSpec
 
         def initialize(klass)
           @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash,key| hash[key] = [] }
+          @stubs = Hash.new { |hash, key| hash[key] = [] }
           @observed_methods = []
           @played_methods = {}
           @klass = klass
@@ -88,14 +88,17 @@ module RSpec
         # Used internally to verify that message expectations have been
         # fulfilled.
         def verify
-          if @expectation_set && !message_chains.all_expectations_fulfilled?
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
-          end
+          return unless @expectation_set
+          return if message_chains.all_expectations_fulfilled?
+
+          raise RSpec::Mocks::MockExpectationError,
+                "Exactly one instance should have received the following " \
+                "message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
         end
 
         # @private
         def stop_all_observation!
-          @observed_methods.each {|method_name| restore_method!(method_name)}
+          @observed_methods.each { |method_name| restore_method!(method_name) }
         end
 
         # @private
@@ -122,7 +125,7 @@ module RSpec
         end
 
         # @private
-        def notify_received_message(object, message, args, blk)
+        def notify_received_message(_object, message, args, _blk)
           has_expectation = false
 
           message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
@@ -130,10 +133,10 @@ module RSpec
             expectation.expectation_fulfilled!
           end
 
-          if has_expectation
-            restore_method!(message)
-            mark_invoked!(message)
-          end
+          return unless has_expectation
+
+          restore_method!(message)
+          mark_invoked!(message)
         end
 
       protected
@@ -167,7 +170,7 @@ module RSpec
         end
 
         def normalize_chain(*args)
-          args.shift.to_s.split('.').map {|s| s.to_sym}.reverse.each {|a| args.unshift a}
+          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
           yield args.first, args
         end
 
@@ -186,13 +189,13 @@ module RSpec
         end
 
         def restore_original_method!(method_name)
-          if @klass.instance_method(method_name).owner == @klass
-            alias_method_name = build_alias_method_name(method_name)
-            @klass.class_exec do
-              remove_method method_name
-              alias_method  method_name, alias_method_name
-              remove_method alias_method_name
-            end
+          return unless @klass.instance_method(method_name).owner == @klass
+
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec do
+            remove_method method_name
+            alias_method method_name, alias_method_name
+            remove_method alias_method_name
           end
         end
 
@@ -219,7 +222,7 @@ module RSpec
           if RSpec::Mocks.configuration.verify_partial_doubles?
             unless public_protected_or_private_method_defined?(method_name)
               raise MockExpectationError,
-                "#{@klass} does not implement ##{method_name}"
+                    "#{@klass} does not implement ##{method_name}"
             end
           end
 
@@ -229,14 +232,14 @@ module RSpec
           recorder = self
           @klass.__send__(:define_method, method_name) do |*args, &blk|
             recorder.playback!(self, method_name)
-            self.__send__(method_name, *args, &blk)
+            __send__(method_name, *args, &blk)
           end
         end
 
         def mark_invoked!(method_name)
           backup_method!(method_name)
           recorder = self
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
+          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
             invoked_instance = recorder.instance_that_received(method_name)
             inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
             raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{inspect} but has already been received by #{invoked_instance}"
@@ -250,15 +253,14 @@ module RSpec
             return unless problem_mod
 
             raise RSpec::Mocks::MockExpectationError,
-              "Using `any_instance` to stub a method (#{method_name}) that has been " +
-              "defined on a prepended module (#{problem_mod}) is not supported."
+                  "Using `any_instance` to stub a method (#{method_name}) that has been " \
+                  "defined on a prepended module (#{problem_mod}) is not supported."
           end
         else
-          def allow_no_prepended_module_definition_of(method_name)
+          def allow_no_prepended_module_definition_of(_method_name)
             # nothing to do; prepends aren't supported on this version of ruby
           end
         end
-
       end
     end
   end

data/lib/rspec/mocks/any_instance/stub_chain.rb

@@ -3,7 +3,6 @@ module RSpec
     module AnyInstance
       # @private
       class StubChain < Chain
-
         # @private
         def expectation_fulfilled?
           true
@@ -36,10 +35,9 @@ module RSpec
           }
         end
 
-        def verify_invocation_order(rspec_method_name, *args, &block)
-          unless invocation_order[rspec_method_name].include?(last_message)
-            raise(NoMethodError, "Undefined method #{rspec_method_name}")
-          end
+        def verify_invocation_order(rspec_method_name, *_args, &_block)
+          return if invocation_order[rspec_method_name].include?(last_message)
+          raise NoMethodError, "Undefined method #{rspec_method_name}"
         end
       end
     end

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -46,10 +46,10 @@ module RSpec
         @expected_args = expected_args
 
         @matchers = case expected_args.first
-          when ArgumentMatchers::AnyArgsMatcher then Array
-          when ArgumentMatchers::NoArgsMatcher  then []
-          else expected_args
-        end
+                    when ArgumentMatchers::AnyArgsMatcher then Array
+                    when ArgumentMatchers::NoArgsMatcher  then []
+                    else expected_args
+                    end
       end
 
       # @api public

data/lib/rspec/mocks/argument_matchers.rb

@@ -1,6 +1,10 @@
+# This cannot take advantage of our relative requires, since this file is a
+# dependency of `rspec/mocks/argument_list_matcher.rb`. See comment there for
+# details.
+require 'rspec/support/matcher_definition'
+
 module RSpec
   module Mocks
-
     # ArgumentMatchers are placeholders that you can include in message
     # expectations to match arguments against a broader check than simple
     # equality.
@@ -110,7 +114,7 @@ module RSpec
       #
       #   expect(object).to receive(:message).with(kind_of(Thing))
       def kind_of(klass)
-        klass
+        KindOf.new(klass)
       end
 
       alias_method :a_kind_of, :kind_of
@@ -131,7 +135,7 @@ module RSpec
 
       # @private
       class AnyArgMatcher
-        def ===(other)
+        def ===(_other)
           true
         end
 
@@ -166,14 +170,14 @@ module RSpec
 
         def ===(predicate, actual)
           @expected.__send__(predicate) do |k, v|
-            actual.has_key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
+            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
           end
         rescue NoMethodError
           false
         end
 
         def description(name)
-          "#{name}(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+          "#{name}(#{@expected.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
         end
       end
 
@@ -221,7 +225,7 @@ module RSpec
         end
 
         def ===(value)
-          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
+          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
         end
 
         def description
@@ -244,6 +248,35 @@ module RSpec
         end
       end
 
+      # @private
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual)
+          actual.kind_of?(@klass)
+        end
+
+        def description
+          "kind of #{@klass.name}"
+        end
+      end
+
+      matcher_namespace = name + '::'
+      ::RSpec::Support.register_matcher_definition do |object|
+        # This is the best we have for now. We should tag all of our matchers
+        # with a module or something so we can test for it directly.
+        #
+        # (Note Module#parent in ActiveSupport is defined in a similar way.)
+        begin
+          object.class.name.include?(matcher_namespace)
+        rescue NoMethodError
+          # Some objects, like BasicObject, don't implemented standard
+          # reflection methods.
+          false
+        end
+      end
     end
   end
 end

data/lib/rspec/mocks/configuration.rb

@@ -2,7 +2,6 @@ module RSpec
   module Mocks
     # Provides configuration options for rspec-mocks.
     class Configuration
-
       def initialize
         @yield_receiver_to_any_instance_implementation_blocks = true
         @verify_doubled_constant_names = false
@@ -22,13 +21,11 @@ module RSpec
       # @example
       #
       #   RSpec.configure do |rspec|
-      #     rspec.mock_with :rspc do |mocks|
+      #     rspec.mock_with :rspec do |mocks|
       #       mocks.yield_receiver_to_any_instance_implementation_blocks = false
       #     end
       #   end
-      def yield_receiver_to_any_instance_implementation_blocks=(arg)
-        @yield_receiver_to_any_instance_implementation_blocks = arg
-      end
+      attr_writer :yield_receiver_to_any_instance_implementation_blocks
 
       # Adds `stub` and `should_receive` to the given
       # modules or classes. This is usually only necessary
@@ -105,9 +102,7 @@ module RSpec
       # constant. You probably only want to set this when running your entire
       # test suite, with all production code loaded. Setting this for an
       # isolated unit test will prevent you from being able to isolate it!
-      def verify_doubled_constant_names=(val)
-        @verify_doubled_constant_names = val
-      end
+      attr_writer :verify_doubled_constant_names
 
       def transfer_nested_constants?
         !!@transfer_nested_constants
@@ -115,9 +110,7 @@ module RSpec
 
       # Sets the default for the `transfer_nested_constants` option when
       # stubbing constants.
-      def transfer_nested_constants=(val)
-        @transfer_nested_constants = val
-      end
+      attr_writer :transfer_nested_constants
 
       # When set to true, partial mocks will be verified the same as object
       # doubles. Any stubs will have their arguments checked against the original