surrogate 0.3.2 → 0.4.2

data/Rakefile

@@ -1 +1,13 @@
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :rspec do |t|
+  t.rspec_opts = [
+    '--fail-fast',
+    '--colour',
+    '--format', 'documentation',
+  ]
+end
+
+task default: :rspec

data/Readme.md

@@ -64,13 +64,14 @@ end
 MockClient.new.request 3 # => ["result1", "result2", "result3"]
 ```
 
-You don't need a **default if you set the ivar** of the same name
+You don't need a **default if you set the ivar** of the same name (replace `?` with `_p` for predicates, since you can't have question marks in ivar names)
 
 ```ruby
 class MockClient
   Surrogate.endow self
-  define(:initialize) { |id| @id = id }
+  define(:initialize) { |id| @id, @connected_p = id, true }
   define :id
+  define :connected?
 end
 MockClient.new(12).id # => 12
 ```
@@ -318,7 +319,7 @@ end
 # doesn't matter that real user has a name as long as it has initialize and id
 MockUser.should substitute_for User, subset: true
 
-# but now it fails b/c it has no addres
+# but now it fails b/c it has no address
 MockUser.define :address
 MockUser.should_not substitute_for User, subset: true
 ```
@@ -332,7 +333,7 @@ the initializer, you can pass a factory to your class, you can give the class th
 setter and then override it whenever you feel it is necessary, you can use RSpec's `#stub` method to put
 it into place.
 
-Personally, I use [Deject](https://rubygems.org/gems/deject) another gem I wrote. For more on why I feel
+Personally, I use [Deject](https://rubygems.org/gems/deject), another gem I wrote. For more on why I feel
 it is a better solution than the above methods, see it's [readme](https://github.com/JoshCheek/deject/tree/938edc985c65358c074a7c7b7bbf18dc11e9450e#why-write-this).
 
 
@@ -346,6 +347,7 @@ Special Thanks
 ==============
 
 * [Kyle Hargraves](https://github.com/pd) for changing the name of his internal gem so that I could take Surrogate
+* [David Chelimsky](http://blog.davidchelimsky.net/) for pairing with me to make Surrogate integrate better with RSpec
 * [Corey Haines](http://coreyhaines.com/) for pairing on substitutability with me
 * [Enova](http://www.enovafinancial.com/) for giving me time and motivation to work on this during Enova Labs.
 * [8th Light](http://8thlight.com/) for giving me time to work on this during our weekly Wazas, and the general encouragement and interest
@@ -361,7 +363,6 @@ TODO
 Future Features
 ---------------
 
-* Support all RSpec matchers (hash_including, anything, etc. see them in RSpec::Mocks::ArgumentMatchers)
 * have some sort of reinitialization that can hook into setup/teardown steps of test suite
 * Support arity checking as part of substitutability
 * Support for blocks

data/lib/surrogate/endower.rb

@@ -55,7 +55,7 @@ class Surrogate
         @hijacking_initialize = false
       end
       initialize = klass.instance_method :initialize
-      klass.send :define_method, :initialize do |*args, &block|
+      klass.__send__ :define_method, :initialize do |*args, &block|
         initialize.bind(self).call(*args, &block)
       end
     end
@@ -65,7 +65,7 @@ class Surrogate
     end
 
     def remember_invocations_for_instances_of(klass)
-      klass.send :define_method, :invocations do |method_name|
+      klass.__send__ :define_method, :invocations do |method_name|
         @hatchling.invocations method_name
       end
     end

data/lib/surrogate/hatchery.rb

@@ -30,11 +30,11 @@ class Surrogate
     private
 
     def klass_can_define_api_methods
-      klass.singleton_class.send :define_method, :define, &method(:define)
+      klass.singleton_class.__send__ :define_method, :define, &method(:define)
     end
 
     def add_api_method_for(method_name)
-      klass.send :define_method, method_name do |*args, &block|
+      klass.__send__ :define_method, method_name do |*args, &block|
         @hatchling.invoke_method method_name, args, &block
       end
     end
@@ -48,7 +48,7 @@ class Surrogate
     end
 
     def add_helpers_for(method_name, helper_name)
-      klass.send :define_method, helper_name do |*args, &block|
+      klass.__send__ :define_method, helper_name do |*args, &block|
         @hatchling.prepare_method method_name, args, &block
         self
       end

data/lib/surrogate/hatchling.rb

@@ -31,19 +31,28 @@ class Surrogate
 
     # maybe these four should be extracted into their own class
     def has_ivar?(method_name)
-      instance.instance_variable_defined? "@#{method_name}"
+      instance.instance_variable_defined? ivar_for method_name
     end
 
     def set_ivar(method_name, value)
-      instance.instance_variable_set "@#{method_name}", value
+      instance.instance_variable_set ivar_for(method_name), value
     end
 
     def get_ivar(method_name)
-      instance.instance_variable_get "@#{method_name}"
+      instance.instance_variable_get ivar_for method_name
     end
 
     def unset_ivar(method_name)
-      instance.send :remove_instance_variable, "@#{method_name}"
+      instance.__send__ :remove_instance_variable, ivar_for(method_name)
+    end
+
+    def ivar_for(method_name)
+      case method_name
+      when /\?$/
+        "@#{method_name.to_s.chop}_p"
+      else
+        "@#{method_name}"
+      end
     end
 
   private

data/lib/surrogate/rspec/api_method_matchers.rb

@@ -50,14 +50,14 @@ class Surrogate
       end
 
       def inspect_arguments(arguments)
-        inspected_arguments = arguments.map { |argument| MessagesFor.inspect_argument argument }
-        inspected_arguments << 'no_args' if inspected_arguments.empty?
-        %Q(`#{inspected_arguments.join ", "}')
+        inspected_arguments = arguments.map { |argument| inspect_argument argument }
+        inspected_arguments << 'no args' if inspected_arguments.empty?
+        "`" << inspected_arguments.join(", ") << "'"
       end
 
       def inspect_argument(to_inspect)
-        if to_inspect.kind_of? ::RSpec::Mocks::ArgumentMatchers::NoArgsMatcher
-          "no_args"
+        if RSpec.rspec_mocks_loaded? && to_inspect.respond_to?(:description)
+          to_inspect.description
         else
           to_inspect.inspect
         end
@@ -67,8 +67,9 @@ class Surrogate
     end
 
 
+    # sigh, surely there is a better name!
     class Handler < Struct.new(:subject, :language_type)
-      attr_accessor :instance, :message_type
+      attr_accessor :instance
 
       def message_for(message_category, message_type)
         MessagesFor.message_for(language_type, message_category, message_type, binding)
@@ -79,7 +80,7 @@ class Surrogate
       end
 
       def message_type
-        @message_type || :default
+        :default
       end
 
       def invocations
@@ -105,23 +106,45 @@ class Surrogate
       def failure_message_for_should_not
         message_for :should_not, message_type
       end
-    end
 
+      def times(times_invoked)
+        # is there a good way to remove these conditionals?
+        extend (kind_of?(MatchWithArguments) ? MatchNumTimesWith : MatchNumTimes)
+        self.expected_times_invoked = times_invoked
+        self
+      end
 
-    module MatchWithArguments
-      def self.extended(klass)
-        klass.message_type = :with
+      def with(*arguments)
+        extend (kind_of?(MatchNumTimes) ? MatchNumTimesWith : MatchWithArguments)
+        self.expected_arguments = arguments
+        self
       end
+    end
 
-      attr_accessor :expected_arguments
 
-      def match? # eventually this will need to get a lot smarter
-        if expected_arguments.size == 1 && expected_arguments.first.kind_of?(::RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
-          invocations.include? []
+    module ArgumentComparer
+      def args_match?(actual_arguments)
+        if RSpec.rspec_mocks_loaded?
+          rspec_arg_expectation = ::RSpec::Mocks::ArgumentExpectation.new *expected_arguments
+          rspec_arg_expectation.args_match? *actual_arguments
         else
-          invocations.include? expected_arguments
+          expected_arguments == actual_arguments
         end
       end
+    end
+
+    module MatchWithArguments
+      include ArgumentComparer
+
+      attr_accessor :expected_arguments
+
+      def message_type
+        :with
+      end
+
+      def match?
+        invocations.any? { |invocation| args_match? invocation }
+      end
 
       def actual_invocation
         return message_for :other, :not_invoked if times_invoked.zero?
@@ -132,8 +155,8 @@ class Surrogate
 
 
     module MatchNumTimes
-      def self.extended(klass)
-        klass.message_type = :times
+      def message_type
+        :times
       end
 
       attr_accessor :expected_times_invoked
@@ -145,14 +168,16 @@ class Surrogate
 
 
     module MatchNumTimesWith
-      def self.extended(klass)
-        klass.message_type = :with_times
+      include ArgumentComparer
+
+      def message_type
+        :with_times
       end
 
       attr_accessor :expected_times_invoked, :expected_arguments
 
       def times_invoked_with_expected_args
-        invocations.select { |invocation| invocation == expected_arguments }.size
+        invocations.select { |invocation| args_match? invocation }.size
       end
 
       def match?
@@ -166,75 +191,37 @@ class Surrogate
     end
 
 
+    surrogate_matcher = lambda do |use_case, matcher, morphable=false|
+      if morphable
+        matcher.chain(:times) { |number|     use_case.times  number     }
+        matcher.chain(:with)  { |*arguments| use_case.with   *arguments }
+      end
 
-
-
-    # have_been_told_to
-    ::RSpec::Matchers.define :have_been_told_to do |verb|
-      use_case = Handler.new verb, :verb
-
-      match do |mocked_instance|
+      matcher.match do |mocked_instance|
         use_case.instance = mocked_instance
         use_case.match?
       end
 
-      chain :times do |number|
-        use_case.extend (use_case.kind_of?(MatchWithArguments) ? MatchNumTimesWith : MatchNumTimes)
-        use_case.expected_times_invoked = number
-      end
+      matcher.failure_message_for_should     { use_case.failure_message_for_should }
+      matcher.failure_message_for_should_not { use_case.failure_message_for_should_not }
+    end
 
-      chain :with do |*arguments|
-        use_case.extend (use_case.kind_of?(MatchNumTimes) ? MatchNumTimesWith : MatchWithArguments)
-        use_case.expected_arguments = arguments
-      end
 
-      failure_message_for_should     { use_case.failure_message_for_should }
-      failure_message_for_should_not { use_case.failure_message_for_should_not }
+    # have_been_told_to
+    ::RSpec::Matchers.define :have_been_told_to do |verb|
+      surrogate_matcher[Handler.new(verb, :verb), self, true]
     end
 
 
     # have_been_asked_for_its
     ::RSpec::Matchers.define :have_been_asked_for_its do |noun|
-      use_case = Handler.new noun, :noun
-
-      match do |mocked_instance|
-        use_case.instance = mocked_instance
-        use_case.match?
-      end
-
-      chain :times do |number|
-        use_case.extend (use_case.kind_of?(MatchWithArguments) ? MatchNumTimesWith : MatchNumTimes)
-        use_case.expected_times_invoked = number
-      end
-
-      chain :with do |*arguments|
-        use_case.extend (use_case.kind_of?(MatchNumTimes) ? MatchNumTimesWith : MatchWithArguments)
-        use_case.expected_arguments = arguments
-      end
-
-      failure_message_for_should     { use_case.failure_message_for_should }
-      failure_message_for_should_not { use_case.failure_message_for_should_not }
+      surrogate_matcher[Handler.new(noun, :noun), self, true]
     end
 
 
     # have_been_initialized_with
     ::RSpec::Matchers.define :have_been_initialized_with do |*init_args|
-      use_case = Handler.new :initialize, :verb
-      use_case.extend MatchWithArguments
-      use_case.expected_arguments = init_args
-
-      match do |mocked_instance|
-        use_case.instance = mocked_instance
-        use_case.match?
-      end
-
-      failure_message_for_should do
-        use_case.failure_message_for_should
-      end
-
-      failure_message_for_should_not do
-        use_case.failure_message_for_should_not
-      end
+      surrogate_matcher[Handler.new(:initialize, :verb).with(*init_args), self]
     end
   end
 end

data/lib/surrogate/rspec.rb

@@ -1,4 +1,25 @@
 # Maybe I should be my own gem?
+
+class Surrogate
+  module RSpec
+    class << self
+      def rspec_mocks_loaded?
+        return @mocks_loaded if @alrady_checked_mocks
+        @alrady_checked_mocks = true
+        require 'rspec/mocks' # can't figure out a way to do this lazily
+        @mocks_loaded = true
+      rescue LoadError
+        @mocks_loaded = false
+      end
+
+      def rspec_mocks_loaded=(bool)
+        @alrady_checked_mocks = true
+        @mocks_loaded = bool
+      end
+    end
+  end
+end
+
 require 'surrogate'
 require 'surrogate/rspec/api_method_matchers'
 require 'surrogate/rspec/substitutability_matchers'

data/lib/surrogate/values.rb

@@ -7,8 +7,13 @@ class Surrogate
     # convert raw arguments into a value
     def self.factory(*args, &block)
       arg = args.first
+      # if arg.kind_of? Exception
+      #   Raiseable.new arg
+      # else
+      #   MethodQueue.new args
+      # end
       if args.size > 1
-        MethodQueue.new args
+        ValueQueue.new args
       elsif arg.kind_of? Exception
         Raisable.new arg
       elsif arg.kind_of? Value
@@ -45,7 +50,7 @@ class Surrogate
     end
 
 
-    class MethodQueue < Value
+    class ValueQueue < Value
       QueueEmpty = Class.new StandardError
 
       def value(hatchling, method_name)

data/lib/surrogate/version.rb

@@ -1,3 +1,3 @@
 class Surrogate
-  VERSION = "0.3.2"
+  VERSION = "0.4.2"
 end

data/spec/defining_api_methods_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe 'define' do
+  let(:mocked_class) { Surrogate.endow Class.new }
+  let(:instance)     { mocked_class.new }
+
   describe 'in the block' do
     it 'is an api method for the class' do
       pristine_klass = Class.new do
@@ -18,248 +21,253 @@ describe 'define' do
 
 
   describe 'out of the block' do
-    let(:mocked_class) { Surrogate.endow Class.new }
-    let(:instance)     { mocked_class.new }
-
     it 'is an api method for the instance' do
       mocked_class.define(:book) { 'book' }
       instance.book.should == 'book'
     end
+  end
 
-    describe 'declaring the behaviour' do
-      describe 'for verbs' do
-        before     { mocked_class.define :wink }
-
-        describe 'will_<api_method>' do
-          it 'overrides the default value for the api method' do
-            mock1 = mocked_class.new
-            mock2 = mocked_class.new
-            mock1.will_wink :quickly
-            mock2.will_wink :slowly
-            mock1.wink.should == :quickly
-            mock2.wink.should == :slowly
-            mock1.wink.should == :quickly
-          end
+  describe 'declaring the behaviour' do
 
-          it 'returns the object' do
-            instance = mocked_class.new
-            instance.will_wink(:quickly).should equal instance
-          end
+    describe 'for verbs' do
+      before     { mocked_class.define :wink }
+
+      describe 'will_<api_method>' do
+        it 'overrides the default value for the api method' do
+          mock1 = mocked_class.new
+          mock2 = mocked_class.new
+          mock1.will_wink :quickly
+          mock2.will_wink :slowly
+          mock1.wink.should == :quickly
+          mock2.wink.should == :slowly
+          mock1.wink.should == :quickly
         end
 
-        describe 'will_<api_method> with multiple arguments' do
-          it 'returns the object' do
-            instance = mocked_class.new
-            instance.will_wink(1, 2, 3).should equal instance
-          end
+        it 'returns the object' do
+          instance = mocked_class.new
+          instance.will_wink(:quickly).should equal instance
+        end
+      end
 
-          context 'it creates a queue of things to find then returns to normal behaviour' do
-            specify 'when there is no default block' do
-              mock = mocked_class.new
-              mock.will_wink :quickly, :slowly
-              mock.wink.should == :quickly
-              mock.wink.should == :slowly
-              expect { mock.wink }.to raise_error Surrogate::UnpreparedMethodError
-            end
+      describe 'will_<api_method> with multiple arguments' do
+        it 'returns the object' do
+          instance = mocked_class.new
+          instance.will_wink(1, 2, 3).should equal instance
+        end
 
-            specify 'when there is a default block' do
-              mocked_class = Surrogate.endow(Class.new)
-              mocked_class.define(:connect) { :default }
-              mock = mocked_class.new
-              mock.will_connect 1, 2
-              mock.connect.should == 1
-              mock.connect.should == 2
-              mock.connect.should == :default
-            end
+        context 'it creates a queue of things to find then returns to normal behaviour' do
+          specify 'when there is no default block' do
+            mock = mocked_class.new
+            mock.will_wink :quickly, [:slowly]
+            mock.wink.should == :quickly
+            mock.wink.should == [:slowly]
+            expect { mock.wink }.to raise_error Surrogate::UnpreparedMethodError
           end
-        end
 
-        describe 'when an argument is an error' do
-          it 'raises the error on method invocation' do
+          specify 'when there is a default block' do
             mocked_class = Surrogate.endow(Class.new)
-            mocked_class.define :connect
+            mocked_class.define(:connect) { :default }
             mock = mocked_class.new
-            error = StandardError.new("some message")
-
-            # for single invocation
-            mock.will_connect error
-            expect { mock.connect }.to raise_error StandardError, "some message"
-
-            # for queue
-            mock.will_connect 1, error, 2
+            mock.will_connect 1, 2
             mock.connect.should == 1
-            expect { mock.connect }.to raise_error StandardError, "some message"
             mock.connect.should == 2
+            mock.connect.should == :default
           end
         end
       end
 
+      describe 'when an argument is an error' do
+        it 'raises the error on method invocation' do
+          mocked_class = Surrogate.endow(Class.new)
+          mocked_class.define :connect
+          mock = mocked_class.new
+          error = StandardError.new("some message")
+
+          # for single invocation
+          mock.will_connect error
+          expect { mock.connect }.to raise_error StandardError, "some message"
+
+          # for queue
+          mock.will_connect 1, error, 2
+          mock.connect.should == 1
+          expect { mock.connect }.to raise_error StandardError, "some message"
+          mock.connect.should == 2
+        end
+      end
+    end
 
-      describe 'for nouns' do
-        before { mocked_class.define :age }
 
-        describe 'will_have_<api_method>' do
-          it 'defines will_have_<api_method> which overrides the default block' do
-            mock1 = mocked_class.new
-            mock2 = mocked_class.new
-            mock1.will_have_age 12
-            mock2.will_have_age 34
-            mock1.age.should == 12
-            mock2.age.should == 34
-            mock1.age.should == 12
-          end
+    describe 'for nouns' do
+      before { mocked_class.define :age }
 
-          it 'returns the object' do
-            instance = mocked_class.new
-            instance.will_have_age(123).should equal instance
-          end
+      describe 'will_have_<api_method>' do
+        it 'defines will_have_<api_method> which overrides the default block' do
+          mock1 = mocked_class.new
+          mock2 = mocked_class.new
+          mock1.will_have_age 12
+          mock2.will_have_age 34
+          mock1.age.should == 12
+          mock2.age.should == 34
+          mock1.age.should == 12
         end
 
-        describe 'wil_have_<api_method> with multiple arguments' do
-          it 'returns the object' do
-            instance = mocked_class.new
-            instance.will_have_age(1,2,3).should equal instance
-          end
+        it 'returns the object' do
+          instance = mocked_class.new
+          instance.will_have_age(123).should equal instance
+        end
+      end
 
-          context 'it creates a queue of things to find then returns to normal behaviour' do
-            specify 'when there is no default block' do
-              mock = mocked_class.new
-              mock.will_have_age 12, 34
-              mock.age.should == 12
-              mock.age.should == 34
-              expect { mock.age }.to raise_error Surrogate::UnpreparedMethodError
-            end
+      describe 'wil_have_<api_method> with multiple arguments' do
+        it 'returns the object' do
+          instance = mocked_class.new
+          instance.will_have_age(1,2,3).should equal instance
+        end
 
-            specify 'when there is a default block' do
-              mocked_class = Surrogate.endow(Class.new)
-              mocked_class.define(:name) { 'default' }
-              mock = mocked_class.new
-              mock.will_have_name 'a', 'b'
-              mock.name.should == 'a'
-              mock.name.should == 'b'
-              mock.name.should == 'default'
-            end
+        context 'it creates a queue of things to find then returns to normal behaviour' do
+          specify 'when there is no default block' do
+            mock = mocked_class.new
+            mock.will_have_age 12, 34
+            mock.age.should == 12
+            mock.age.should == 34
+            expect { mock.age }.to raise_error Surrogate::UnpreparedMethodError
+          end
+
+          specify 'when there is a default block' do
+            mocked_class = Surrogate.endow(Class.new)
+            mocked_class.define(:name) { 'default' }
+            mock = mocked_class.new
+            mock.will_have_name 'a', 'b'
+            mock.name.should == 'a'
+            mock.name.should == 'b'
+            mock.name.should == 'default'
           end
         end
       end
     end
+  end
 
 
 
-    context 'the api method' do
-      it 'takes any number of arguments' do
-        mocked_class.define(:meth) { 1 }
-        mocked_class.new.meth.should == 1
-        mocked_class.new.meth(1).should == 1
-        mocked_class.new.meth(1, 2).should == 1
-      end
+  context 'the api method' do
+    it 'takes any number of arguments' do
+      mocked_class.define(:meth) { 1 }
+      mocked_class.new.meth.should == 1
+      mocked_class.new.meth(1).should == 1
+      mocked_class.new.meth(1, 2).should == 1
+    end
 
-      it 'raises an UnpreparedMethodError when it has no default block' do
-        mocked_class.define :meth
-        expect { mocked_class.new.meth }.to raise_error(Surrogate::UnpreparedMethodError, /meth/)
-      end
+    it 'raises an UnpreparedMethodError when it has no default block' do
+      mocked_class.define :meth
+      expect { mocked_class.new.meth }.to raise_error(Surrogate::UnpreparedMethodError, /meth/)
+    end
 
-      it 'considers ivars of the same name to be its default' do
-        mocked_class.define :meth
-        mocked = mocked_class.new
-        mocked.instance_variable_set :@meth, 123
-        mocked.meth.should == 123
-      end
+    it 'considers ivars of the same name to be its default when it has no suffix' do
+      mocked_class.define :meth
+      mocked = mocked_class.new
+      mocked.instance_variable_set :@meth, 123
+      mocked.meth.should == 123
+    end
+
+    it 'considers ivars ending in _p to be its default when it ends in a question mark' do
+      mocked_class.define :meth?
+      mocked = mocked_class.new
+      mocked.instance_variable_set :@meth_p, 123
+      mocked.meth?.should == 123
+    end
+
+    it 'reverts to the default block if invoked and having no ivar' do
+      mocked_class.define(:meth) { 123 }
+      mocked = mocked_class.new
+      mocked.instance_variable_get(:@meth).should be_nil
+      mocked.meth.should == 123
+    end
 
-      it 'reverts to the default block if invoked and having no ivar' do
-        mocked_class.define(:meth) { 123 }
-        mocked = mocked_class.new
-        mocked.instance_variable_get(:@meth).should be_nil
-        mocked.meth.should == 123
+    describe 'initialization' do
+      specify 'api methods can be an initialize method' do
+        mocked_class.define(:initialize) { @abc = 123 }
+        mocked_class.new.instance_variable_get(:@abc).should == 123
       end
 
-      describe 'initialization' do
-        specify 'api methods can be an initialize method' do
-          mocked_class.define(:initialize) { @abc = 123 }
-          mocked_class.new.instance_variable_get(:@abc).should == 123
-        end
+      specify 'initialize exsits even if error is raised' do
+        mocked_class.define(:initialize) { raise "simulate runtime error" }
+        expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
+        expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
+      end
 
-        specify 'initialize exsits even if error is raised' do
-          mocked_class.define(:initialize) { raise "simulate runtime error" }
-          expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
-          expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
-        end
+      specify 'receives args' do
+        mocked_class.define(:initialize) { |num1, num2| @num = num1 + num2 }
+        mocked_class.new(25, 75).instance_variable_get(:@num).should == 100
+      end
 
-        specify 'receives args' do
-          mocked_class.define(:initialize) { |num1, num2| @num = num1 + num2 }
-          mocked_class.new(25, 75).instance_variable_get(:@num).should == 100
-        end
+      specify 'even works with inheritance' do
+        superclass = Class.new
+        superclass.send(:define_method, :initialize) { @a = 1 }
+        subclass = Surrogate.endow Class.new superclass
+        subclass.define :abc
+        subclass.new.instance_variable_get(:@a).should == 1
+      end
 
-        specify 'even works with inheritance' do
-          superclass = Class.new
-          superclass.send(:define_method, :initialize) { @a = 1 }
-          subclass = Surrogate.endow Class.new superclass
-          subclass.define :abc
-          subclass.new.instance_variable_get(:@a).should == 1
+      context 'when not an api method' do
+        it 'respects arity (this is probably 1.9.3 only)' do
+          expect { mocked_class.new 1 }.to raise_error ArgumentError, 'wrong number of arguments(1 for 0)'
         end
 
-        context 'when not an api method' do
-          it 'respects arity (this is probably 1.9.3 only)' do
-            expect { mocked_class.new 1 }.to raise_error ArgumentError, 'wrong number of arguments(1 for 0)'
-          end
-
-          describe 'invocations are recorded anyway' do
-            specify 'even when initialize is defined after surrogate block' do
-              klass = Class.new do
-                Surrogate.endow self
-                def initialize(a) @a = a end
-              end
-              klass.new(1).should have_been_initialized_with 1
-              klass.new(1).instance_variable_get(:@a).should == 1
+        describe 'invocations are recorded anyway' do
+          specify 'even when initialize is defined after surrogate block' do
+            klass = Class.new do
+              Surrogate.endow self
+              def initialize(a) @a = a end
             end
+            klass.new(1).should have_been_initialized_with 1
+            klass.new(1).instance_variable_get(:@a).should == 1
+          end
 
-            specify 'even when initialize is defined before surrogate block' do
-              klass = Class.new do
-                def initialize(a) @a = a end
-                Surrogate.endow self
-              end
-              klass.new(1).should have_been_initialized_with 1
-              klass.new(1).instance_variable_get(:@a).should == 1
+          specify 'even when initialize is defined before surrogate block' do
+            klass = Class.new do
+              def initialize(a) @a = a end
+              Surrogate.endow self
             end
+            klass.new(1).should have_been_initialized_with 1
+            klass.new(1).instance_variable_get(:@a).should == 1
           end
         end
       end
+    end
 
-      describe 'it takes a block whos return value will be used as the default' do
-        specify 'the block is instance evaled' do
-          mocked_class.define(:meth) { self }
-          instance = mocked_class.new
-          instance.meth.should equal instance
-        end
-
-        specify 'arguments passed to the method will be passed to the block' do
-          mocked_class.define(:meth) { |*args| args }
-          instance = mocked_class.new
-          instance.meth(1).should == [1]
-          instance.meth(1, 2).should == [1, 2]
-        end
+    describe 'it takes a block whos return value will be used as the default' do
+      specify 'the block is instance evaled' do
+        mocked_class.define(:meth) { self }
+        instance = mocked_class.new
+        instance.meth.should equal instance
       end
 
-      it 'remembers what it was invoked with' do
-        mocked_class.define(:meth) { nil }
-        mock = mocked_class.new
-        mock.meth 1
-        mock.meth 1, 2
-        mock.meth [1, 2]
-        mock.invocations(:meth).should == [
-          [1],
-          [1, 2],
-          [[1, 2]],
-        ]
+      specify 'arguments passed to the method will be passed to the block' do
+        mocked_class.define(:meth) { |*args| args }
+        instance = mocked_class.new
+        instance.meth(1).should == [1]
+        instance.meth(1, 2).should == [1, 2]
       end
+    end
 
-      it 'raises an error if asked about invocations for api methods it does not know' do
-        mocked_class.define :meth1
-        mocked_class.define :meth2
-        mock = mocked_class.new
-        expect { mock.invocations(:meth1) }.to_not raise_error
-        expect { mock.invocations(:meth3) }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "initialize", "meth1", "meth2"/
-      end
+    it 'remembers what it was invoked with' do
+      mocked_class.define(:meth) { nil }
+      mock = mocked_class.new
+      mock.meth 1
+      mock.meth 1, 2
+      mock.meth [1, 2]
+      mock.invocations(:meth).should == [
+        [1],
+        [1, 2],
+        [[1, 2]],
+      ]
+    end
+
+    it 'raises an error if asked about invocations for api methods it does not know' do
+      mocked_class.define :meth1
+      mocked_class.define :meth2
+      mock = mocked_class.new
+      expect { mock.invocations(:meth1) }.to_not raise_error
+      expect { mock.invocations(:meth3) }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "initialize", "meth1", "meth2"/
     end
   end
 

data/spec/rspec/have_been_asked_for_its_spec.rb

@@ -60,12 +60,17 @@ describe 'RSpec matchers', 'have_been_asked_for_its' do
     end
 
     describe 'integration with rspec argument_matchers' do
-      it 'works with no_args' do
+      it 'works with rspec matchers' do
         instance.should_not have_been_asked_for_its(:size).with(no_args)
         instance.size(1)
         instance.should_not have_been_asked_for_its(:size).with(no_args)
         instance.size
         instance.should have_been_asked_for_its(:size).with(no_args)
+
+        instance.should_not have_been_asked_for_its(:size).with(hash_including all: true)
+        instance.size any: false, all: true
+        instance.should have_been_asked_for_its(:size).with(hash_including all: true)
+        instance.should_not have_been_asked_for_its(:size).with(hash_including all: false)
       end
     end
   end

data/spec/rspec/messages_spec.rb

@@ -11,8 +11,9 @@ describe messages_for, 'argument inspection' do
       messages_for.inspect_argument([/a/]).should == "[/a/]"
     end
 
-    it 'inspects no_args matcher' do
-      messages_for.inspect_argument(no_args).should == 'no_args'
+    it 'inspects rspec matchers' do
+      messages_for.inspect_argument(no_args).should == 'no args'
+      messages_for.inspect_argument(hash_including abc: 123).should == 'hash_including(:abc=>123)'
     end
   end
 
@@ -23,11 +24,11 @@ describe messages_for, 'argument inspection' do
     end
 
     it "joins arguments with commas" do
-      messages_for.inspect_arguments(['x', no_args]).should == "`\"x\", no_args'"
+      messages_for.inspect_arguments(['x', no_args]).should == "`\"x\", no args'"
     end
 
     it 'returns no_args when the array is empty' do
-      messages_for.inspect_arguments([]).should == "`no_args'"
+      messages_for.inspect_arguments([]).should == "`no args'"
     end
   end
 end

data/spec/rspec/rspec_mocks_integration_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'integration with rspec-mocks' do
+
+  let(:mp3) { Surrogate.endow(Class.new).define(:play) { }.new }
+
+  it 'knows that rspec-mocks is loaded' do
+    Surrogate::RSpec.rspec_mocks_loaded?.should equal true
+  end
+
+  context 'when rspec-mocks is loaded' do
+    it 'uses their matchers' do
+      mp3.play "Emily Wells"
+      mp3.should have_been_told_to(:play).with(/emily/i)
+      mp3.should_not have_been_told_to(:play).with(/emily/)
+
+      mp3.play /regex/
+      mp3.should have_been_told_to(:play).with(/regex/)
+      mp3.should_not have_been_told_to(:play).with(/xeger/)
+    end
+  end
+
+  context 'when rspec-mocks is not loaded' do
+    it 'does straight #== comparisons on each argument' do
+      begin
+        Surrogate::RSpec.rspec_mocks_loaded = false
+
+        mp3.play "Emily Wells"
+        mp3.should_not have_been_told_to(:play).with(/emily/i)
+
+        mp3.play /regex/
+        mp3.should have_been_told_to(:play).with(/regex/)
+        mp3.should_not have_been_told_to(:play).with(/xeger/)
+      rescue Exception
+        Surrogate::RSpec.rspec_mocks_loaded = true
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: surrogate
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-03 00:00:00.000000000 Z
+date: 2012-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70198239716160 !ruby/object:Gem::Requirement
+  requirement: &70344532950860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70198239716160
+  version_requirements: *70344532950860
 description: Framework to aid in handrolling mock/spy objects.
 email:
 - josh.cheek@gmail.com
@@ -51,6 +51,7 @@ files:
 - spec/rspec/have_been_initialized_with_spec.rb
 - spec/rspec/have_been_told_to_spec.rb
 - spec/rspec/messages_spec.rb
+- spec/rspec/rspec_mocks_integration_spec.rb
 - spec/rspec/substitute_for_spec.rb
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb
@@ -86,6 +87,7 @@ test_files:
 - spec/rspec/have_been_initialized_with_spec.rb
 - spec/rspec/have_been_told_to_spec.rb
 - spec/rspec/messages_spec.rb
+- spec/rspec/rspec_mocks_integration_spec.rb
 - spec/rspec/substitute_for_spec.rb
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb