surrogate 0.6.0 → 0.6.1

data/Changelog.md

@@ -1,3 +1,9 @@
+### 0.6.1
+
+* bang methods map to ivars suffixed with `_b`, because you can't have a bang in an ivar name
+* Add general syntax for overriding values (e.g. for use with operators) `will_overrides`
+* block assertions can specify that exceptions should get raised (still shitty error messages, though) The interface mimicks RSpec's `#raise_error` matcher
+
 ### 0.6.0
 
 * Setting an override still requires the invoking code to call with the correct signature

data/Readme.md

@@ -78,15 +78,16 @@ end
 MockClient.new.request 3 # => ["result1", "result2", "result3"]
 ```
 
-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)
+You don't need a **default if you set the ivar** of the same name (replace `?` with `_p` for predicates, and `!` with `_b` for bang methods, since you can't have question marks or bangs in ivar names)
 Note that methods without bodies will not have their arguments checked, and will not be asserted against when comparing signatures.
 
 ```ruby
 class MockClient
   Surrogate.endow self
-  define(:initialize) { |id| @id, @connected_p = id, true }
+  define(:initialize) { |id| @id, @connected_p, @reconnect_b = id, true, true }
   define :id
   define :connected?
+  define :reconnect!
 end
 MockClient.new(12).id # => 12
 ```
@@ -458,6 +459,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
+* The people who have paired with me on this: [Corey Haines](http://coreyhaines.com/) on substitutability, [Kori Roys](https://github.com/koriroys) on `#last_instance`, [Wai Lee](https://github.com/skatenerd) on the new assertion syntax
+* The people who have contributed: [Michael Baker](with m://github.com/michaelbaker) on the readme.

data/Readme.md.mountain_berry_fields

@@ -98,16 +98,17 @@ MockClient.new.request 3 # => ["result1", "result2", "result3"]
 <% end %>
 ```
 
-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)
+You don't need a **default if you set the ivar** of the same name (replace `?` with `_p` for predicates, and `!` with `_b` for bang methods, since you can't have question marks or bangs in ivar names)
 Note that methods without bodies will not have their arguments checked, and will not be asserted against when comparing signatures.
 
 ```ruby
 <% test 'overriding default by setting the ivar', with: :magic_comments do %>
 class MockClient
   Surrogate.endow self
-  define(:initialize) { |id| @id, @connected_p = id, true }
+  define(:initialize) { |id| @id, @connected_p, @reconnect_b = id, true, true }
   define :id
   define :connected?
+  define :reconnect!
 end
 MockClient.new(12).id # => 12
 <% end %>
@@ -548,6 +549,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
+* The people who have paired with me on this: [Corey Haines](http://coreyhaines.com/) on substitutability, [Kori Roys](https://github.com/koriroys) on `#last_instance`, [Wai Lee](https://github.com/skatenerd) on the new assertion syntax
+* The people who have contributed: [Michael Baker](with m://github.com/michaelbaker) on the readme.

data/lib/surrogate/endower.rb

@@ -32,10 +32,11 @@ class Surrogate
 
     def endow_klass
       klass.extend ClassMethods
-      add_hatchery_to                        klass
-      enable_defining_methods                klass
+      add_hatchery_to klass
+      enable_defining_methods klass
       klass.send :include, InstanceMethods
-      invoke_hooks                           klass
+      enable_generic_override klass
+      invoke_hooks klass
     end
 
     def endow_singleton_class
@@ -43,10 +44,17 @@ class Surrogate
       enable_defining_methods singleton
       singleton.module_eval &block if block
       klass.instance_variable_set :@hatchling, Hatchling.new(klass, hatchery)
-      invoke_hooks                           singleton
+      invoke_hooks singleton
       klass
     end
 
+    def enable_generic_override(klass)
+      klass.__send__ :define_method, :will_override do |method_name, *args, &block|
+        @hatchling.prepare_method method_name, args, &block
+        self
+      end
+    end
+
     def invoke_hooks(klass)
       self.class.hooks.each { |hook| hook.call klass }
     end

data/lib/surrogate/hatchling.rb

@@ -25,6 +25,7 @@ class Surrogate
     end
 
     def prepare_method(method_name, args, &block)
+      must_know method_name
       set_ivar method_name, Value.factory(*args, &block)
     end
 
@@ -75,11 +76,35 @@ class Surrogate
     end
 
     def ivar_for(method_name)
-      case method_name
-      when /\?$/
-        "@#{method_name.to_s.chop}_p"
-      else
-        "@#{method_name}"
+      method_name = method_name.to_s
+      if    method_name.end_with? ?? then "@#{method_name.to_s.chop}_p"
+      elsif method_name.end_with? ?! then "@#{method_name.to_s.chop}_b"
+      elsif method_name == '[]'      then '@_brackets'
+      elsif method_name == '**'      then '@_splat_splat'
+      elsif method_name == '!@'      then '@_ubang'
+      elsif method_name == '+@'      then '@_uplus'
+      elsif method_name == '-@'      then '@_uminus'
+      elsif method_name == ?*        then '@_splat'
+      elsif method_name == ?/        then '@_divide'
+      elsif method_name == ?%        then '@_percent'
+      elsif method_name == ?+        then '@_plus'
+      elsif method_name == ?-        then '@_minus'
+      elsif method_name == '>>'      then '@_shift_right'
+      elsif method_name == '<<'      then '@_shift_left'
+      elsif method_name == ?&        then '@_ampersand'
+      elsif method_name == ?^        then '@_caret'
+      elsif method_name == ?|        then '@_bang'
+      elsif method_name == '<='      then '@_less_eq'
+      elsif method_name == ?<        then '@_less'
+      elsif method_name == ?>        then '@_greater'
+      elsif method_name == '>='      then '@_greater_eq'
+      elsif method_name == '<=>'     then '@_spaceship'
+      elsif method_name == '=='      then '@_2eq'
+      elsif method_name == '==='     then '@_3eq'
+      elsif method_name == '!='      then '@_not_eq'
+      elsif method_name == '=~'      then '@_eq_tilde'
+      elsif method_name == '!~'      then '@_bang_tilde'
+      else                                "@#{method_name}"
       end
     end
 

data/lib/surrogate/rspec/block_asserter.rb

@@ -0,0 +1,127 @@
+class Surrogate
+  module RSpec
+    class WithFilter
+      class BlockAsserter
+        class RaiseAsserter
+          def initialize(arg, message)
+            @assertion = if arg.kind_of? String
+                           match_message arg
+                         elsif arg.kind_of? Regexp
+                           match_regexp arg
+                         elsif exception_and_message? arg, message
+                           match_exception_and_message arg, message
+                         else
+                           raise ArgumentError, "raising(#{arg.inspect}, #{message.inspect}) are not valid arguments"
+                         end
+          end
+
+          def call(exception)
+            @assertion.call exception
+          end
+
+          private
+
+          def exception_and_message?(exception_class, message)
+            return false unless exception_class.kind_of? Class
+            return false unless exception_class.ancestors.include? Exception
+            return false unless message.kind_of?(NilClass) || message.kind_of?(String) || message.kind_of?(Regexp)
+            true
+          end
+
+          def match_message(message)
+            -> exception { message == exception.message }
+          end
+
+          def match_regexp(regexp)
+            -> exception { regexp =~ exception.message }
+          end
+
+          def match_exception_and_message(exception_class, message)
+            -> exception do
+              return false unless exception.kind_of? exception_class
+              return message == exception.message if message.kind_of? String
+              return message =~ exception.message if message.kind_of? Regexp
+              true
+            end
+          end
+        end
+      end
+
+      class BlockAsserter
+        def initialize(definition_block)
+          @call_with = Invocation.new []
+          definition_block.call self
+        end
+
+        def call_with(*args, &block)
+          @call_with = Invocation.new args, &block
+        end
+
+        def returns(value=nil, &block)
+          @returns = block || lambda { |returned| returned.should == value }
+        end
+
+        def before(&block)
+          @before = block
+        end
+
+        def after(&block)
+          @after = block
+        end
+
+        # arg can be a string      (expected message)
+        #            a regex       (matches the actual message)
+        #            an exception  (type of exception expected to be raised)
+        def raising(arg, message=nil)
+          @raising = RaiseAsserter.new arg, message
+        end
+
+        def arity(n)
+          @arity = n
+        end
+
+        def matches?(block_to_test)
+          matches   = before_matches?       block_to_test
+          matches &&= return_value_matches? block_to_test
+          matches &&= arity_matches?        block_to_test
+          matches &&= after_matches?        block_to_test
+          matches
+        end
+
+        private
+
+        # matches if no return specified, or returned value == specified value
+        # also matches the block
+        def return_value_matches?(block_to_test)
+          returned_value = block_to_test.call(*@call_with.args, &@call_with.block)
+          @returns.call returned_value if @returns
+          @raising.nil?
+        rescue ::RSpec::Expectations::ExpectationNotMetError
+          false
+        rescue Exception # !!!!!!WARNING!!!!!! (look here if things go wrong)
+          @raising && @raising.call($!)
+        end
+
+        # matches if the first time it is called, it raises nothing
+        def before_matches?(*)
+          @before_has_been_invoked || (@before && @before.call)
+        ensure
+          return @before_has_been_invoked = true unless $!
+        end
+
+        # matches if nothing is raised
+        def after_matches?(block_to_test)
+          @after && @after.call
+          true
+        end
+
+        def arity_matches?(block_to_test)
+          return true unless @arity
+          block_to_test.arity == @arity
+        end
+
+        attr_accessor :block_to_test
+      end
+    end
+  end
+end

data/lib/surrogate/rspec/with_filter.rb

@@ -1,75 +1,9 @@
+require 'surrogate/rspec/block_asserter'
+
 class Surrogate
   module RSpec
     class WithFilter
 
-      class BlockAsserter
-        def initialize(definition_block)
-          @call_with = Invocation.new []
-          definition_block.call self
-        end
-
-        def call_with(*args, &block)
-          @call_with = Invocation.new args, &block
-        end
-
-        def returns(value=nil, &block)
-          @returns = block || lambda { |returned| returned.should == value }
-        end
-
-        def before(&block)
-          @before = block
-        end
-
-        def after(&block)
-          @after = block
-        end
-
-        def arity(n)
-          @arity = n
-        end
-
-        def matches?(block_to_test)
-          matches   = before_matches? block_to_test
-          matches &&= return_value_matches? block_to_test
-          matches &&= arity_matches? block_to_test
-          matches &&= after_matches? block_to_test
-          matches
-        end
-
-        private
-
-        # matches if no return specified, or returned value == specified value
-        def return_value_matches?(block_to_test)
-          returned_value = block_to_test.call(*@call_with.args, &@call_with.block)
-          @returns.call returned_value if @returns
-          true
-        rescue ::RSpec::Expectations::ExpectationNotMetError
-          false
-        end
-
-        # matches if the first time it is called, it raises nothing
-        def before_matches?(*)
-          @before_has_been_invoked || (@before && @before.call)
-        ensure
-          return @before_has_been_invoked = true unless $!
-        end
-
-        # matches if nothing is raised
-        def after_matches?(block_to_test)
-          @after && @after.call
-          true
-        end
-
-        def arity_matches?(block_to_test)
-          return true unless @arity
-          block_to_test.arity == @arity
-        end
-
-        attr_accessor :block_to_test
-      end
-
-
-
       class RSpecMatchAsserter
         attr_accessor :actual_invocation, :expected_invocation
 

data/lib/surrogate/version.rb

@@ -1,3 +1,3 @@
 class Surrogate
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

data/spec/defining_api_methods_spec.rb

@@ -65,24 +65,40 @@ describe 'define' do
         end
 
         it 'returns the object' do
-          instance = mocked_class.new
           instance.will_wink(:quickly).should equal instance
         end
       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
 
         # Is there something useful the error could say?
         it 'creates a queue of things to find and raises a QueueEmpty error if there are none left' 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::Value::ValueQueue::QueueEmpty
+          instance.will_wink :quickly, [:slowly]
+          instance.wink.should == :quickly
+          instance.wink.should == [:slowly]
+          expect { instance.wink }.to raise_error Surrogate::Value::ValueQueue::QueueEmpty
+        end
+      end
+
+      describe 'will_override(method_name, ...)' do
+        it 'returns the object' do
+          instance.will_override(:wink, :quickly).should equal instance
+        end
+
+        it 'is a dynamic way to override a value (useful for operators)' do
+          instance.will_override :wink, :quickly
+          instance.wink.should == :quickly
+          instance.will_override :wink, :quickly, [:slowly]
+          instance.wink.should == :quickly
+          instance.wink.should == [:slowly]
+        end
+
+        it 'raises an error if you try to override a nonexistent method' do
+          expect { instance.will_override :whateva, 123 }
+            .to raise_error Surrogate::UnknownMethod, %(doesn't know "whateva", only knows "wink")
         end
       end
 
@@ -90,18 +106,18 @@ describe 'define' do
         it 'raises the error on method invocation' do
           mocked_class = Surrogate.endow(Class.new)
           mocked_class.define :connect
-          mock = mocked_class.new
+          instance = mocked_class.new
           error = StandardError.new("some message")
 
           # for single invocation
-          mock.will_connect error
-          expect { mock.connect }.to raise_error StandardError, "some message"
+          instance.will_connect error
+          expect { instance.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
+          instance.will_connect 1, error, 2
+          instance.connect.should == 1
+          expect { instance.connect }.to raise_error StandardError, "some message"
+          instance.connect.should == 2
         end
       end
     end
@@ -122,24 +138,21 @@ describe 'define' do
         end
 
         it 'returns the object' do
-          instance = mocked_class.new
           instance.will_have_age(123).should equal instance
         end
       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
 
         # Is there something useful the error could say?
         it 'creates a queue of things to find and raises a QueueEmpty error if there are none left' 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::Value::ValueQueue::QueueEmpty
+          instance.will_have_age 12, 34
+          instance.age.should == 12
+          instance.age.should == 34
+          expect { instance.age }.to raise_error Surrogate::Value::ValueQueue::QueueEmpty
         end
       end
     end
@@ -157,35 +170,41 @@ describe 'define' do
 
     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/)
+      expect { instance.meth }.to raise_error Surrogate::UnpreparedMethodError, /meth/
     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
+      instance.instance_variable_set :@meth, 123
+      instance.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
+      instance.instance_variable_set :@meth_p, 123
+      instance.meth?.should == 123
+      instance.will_have_meth? 456
+      instance.meth?.should == 456
+    end
+
+    it 'considers ivars ending in _b to be its default when it ends in a bang' do
+      mocked_class.define :meth!
+      instance.instance_variable_set :@meth_b, 123
+      instance.meth!.should == 123
+      instance.will_have_meth! 456
+      instance.meth!.should == 456
     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
+      instance.instance_variable_get(:@meth).should be_nil
+      instance.meth.should == 123
     end
 
     it 'raises arity errors, even if the value is overridden' do
       mocked_class.define(:meth) { }
-      mocked = mocked_class.new
-      mocked.instance_variable_set :@meth, "abc"
-      expect { mocked.meth "extra", "args" }.to raise_error ArgumentError, /wrong number of arguments \(2 for 0\)/
+      instance.instance_variable_set :@meth, "abc"
+      expect { instance.meth "extra", "args" }.to raise_error ArgumentError, /wrong number of arguments \(2 for 0\)/
     end
 
     it 'does not raise arity errors, when there is no default block and the value is overridden' do
@@ -204,13 +223,11 @@ describe 'define' do
     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
@@ -231,9 +248,8 @@ describe 'define' do
     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 { invocations mock, :meth1 }.to_not raise_error
-      expect { invocations mock, :meth3 }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "meth1", "meth2"/
+      expect { invocations instance, :meth1 }.to_not raise_error
+      expect { invocations instance, :meth3 }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "meth1", "meth2"/
     end
   end
 

data/spec/rspec/block_support_spec.rb

@@ -3,6 +3,10 @@ require 'spec_helper'
 # these all need error messages
 describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
 
+  def fails(&block)
+    expect { block.call }.to raise_error RSpec::Expectations::ExpectationNotMetError
+  end
+
   let(:dir)      { Surrogate.endow(Class.new) { define(:chdir) { |dir_path| nil }}}
   let(:dir_path) { '/some/dir/path' }
 
@@ -21,7 +25,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
     dir.should have_been_told_to(:chdir).with(dir_path) { }
   end
 
-  it "fails if the arguments don't match, even if the block does" do
+  it "fails if the block's arguments don't match" do
     dir.chdir(dir_path) { }
     dir.should_not have_been_told_to(:chdir).with(dir_path.reverse) { }
     dir.should     have_been_told_to(:chdir).with(dir_path) { }
@@ -61,6 +65,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
   let(:file_name) { 'some_file_name.ext' }
   let(:file_body) { 'some file body' }
 
+  # reword this a bit
   describe 'the .before and .after hooks' do
     specify "take blocks which it will evaluate before/after invoking the submitted_block" do
       dir.chdir(dir_path) { file.write file_name, file_body }
@@ -70,7 +75,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
       }
     end
 
-    example "multiple invocations wrong number of times" do
+    example "example: multiple invocations wrong number of times" do
       dir.chdir(dir_path) { file.write file_name, file_body }
       dir.chdir(dir_path) { file.write file_name, file_body }
       dir.should_not have_been_told_to(:chdir).times(1).with(dir_path) { |block|
@@ -79,7 +84,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
       }
     end
 
-    example "multiple invocations correct number of times" do
+    example "example: multiple invocations correct number of times" do
       dir.chdir(dir_path) { file.write file_name, file_body }
       dir.chdir(dir_path) { file.write file_name, file_body }
       dir.should have_been_told_to(:chdir).times(2).with(dir_path) { |block|
@@ -97,9 +102,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
       klass.new.meth { |a,b|   }.should have_been_told_to(:meth).with { |b| b.arity  2 }
       klass.new.meth { |a,b,c| }.should have_been_told_to(:meth).with { |b| b.arity  3 }
       klass.new.meth { |*a|    }.should have_been_told_to(:meth).with { |b| b.arity -1 }
-      expect {
-        klass.new.meth { |a|   }.should have_been_told_to(:meth).with { |b| b.arity 123 }
-      }.to raise_error RSpec::Expectations::ExpectationNotMetError
+      fails { klass.new.meth { |a|   }.should have_been_told_to(:meth).with { |b| b.arity 123 } }
     end
   end
 
@@ -124,6 +127,53 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
   end
 
   describe ".raising is like RSpec's raise_error interface" do
-    it { pending 'IDK what I want this to be like yet' }
+    let(:klass) { Surrogate.endow(Class.new).define(:meth) { |&block| self } }
+
+    it 'fails when an exception is expected but not raised' do
+      fails { klass.new.meth { }.was told_to(:meth).with { |b| b.raising "not whatever" } }
+    end
+
+    it 'fails when an exception is raised but not expected' do
+      fails { klass.new.meth { raise }.was told_to(:meth).with { |b| } }
+    end
+
+    # expect { raise "hello world" }.to raise_error "hello world"
+    it 'can take a string which must match the message' do
+              klass.new.meth { raise "whatever" }.was told_to(:meth).with { |b| b.raising "whatever" }
+      fails { klass.new.meth { raise "whatever" }.was told_to(:meth).with { |b| b.raising "not whatever" } }
+    end
+
+    # expect { raise "hello world" }.to raise_error /hello/
+    it 'can take a regex which must match the message' do
+              klass.new.meth { raise "whatever" }.was told_to(:meth).with { |b| b.raising /whatev/ }
+      fails { klass.new.meth { raise "whatever" }.was told_to(:meth).with { |b| b.raising /not a match/ } }
+    end
+
+    # expect { raise ArgumentError }.to raise_error ArgumentError
+    it 'can take an exception class which must be raised' do
+              klass.new.meth { raise ArgumentError, 'some message' }.was told_to(:meth).with { |b| b.raising ArgumentError }
+      fails { klass.new.meth { raise ArgumentError, 'some message' }.was told_to(:meth).with { |b| b.raising RuntimeError } }
+    end
+
+    # expect { raise ArgumentError, "whatever" }.to raise_error ArgumentError, "whatever"
+    it 'can take an exception class and string' do
+              klass.new.meth { raise ArgumentError, 'whatever' }.was told_to(:meth).with { |b| b.raising ArgumentError, 'whatever' }
+      fails { klass.new.meth { raise RuntimeError,  'whatever' }.was told_to(:meth).with { |b| b.raising ArgumentError, 'whatever' } }
+      fails { klass.new.meth { raise ArgumentError, 'whatever' }.was told_to(:meth).with { |b| b.raising ArgumentError, 'not whatever' } }
+    end
+
+    # expect { raise ArgumentError, 'abc' }.to raise_error ArgumentError, /abc/
+    it 'can take an exception class and regex' do
+              klass.new.meth { raise ArgumentError, "whatever" }.was told_to(:meth).with { |b| b.raising ArgumentError, /what/ }
+      fails { klass.new.meth { raise RuntimeError,  "whatever" }.was told_to(:meth).with { |b| b.raising ArgumentError, /whatever/ } }
+      fails { klass.new.meth { raise ArgumentError, "whatever" }.was told_to(:meth).with { |b| b.raising ArgumentError, /not a match/ } }
+    end
+
+    it 'raises an error when given anything else' do
+      bad_args = -> &block { expect { block.call }.to raise_error ArgumentError, /not valid arguments/ }
+      bad_args.call { klass.new.meth {}.was told_to(:meth).with { |b| b.raising Class             } } # not an exception
+      bad_args.call { klass.new.meth {}.was told_to(:meth).with { |b| b.raising []                } } # not a string/regex
+      bad_args.call { klass.new.meth {}.was told_to(:meth).with { |b| b.raising ArgumentError, [] } } # 2nd param is not a string/regex
+    end
   end
 end

data/spec/unit/map_method_name_to_ivar_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'mapping method names to ivars' do
+  let(:mocked_class) { Surrogate.endow Class.new }
+
+  [ :[]   ,  '@_brackets',
+    :**   ,  '@_splat_splat',
+    :'!@' ,  '@_ubang',
+    :'+@' ,  '@_uplus',
+    :'-@' ,  '@_uminus',
+    :*    ,  '@_splat',
+    :/    ,  '@_divide',
+    :%    ,  '@_percent',
+    :+    ,  '@_plus',
+    :-    ,  '@_minus',
+    :>>   ,  '@_shift_right',
+    :<<   ,  '@_shift_left',
+    :&    ,  '@_ampersand',
+    :^    ,  '@_caret',
+    :|    ,  '@_bang',
+    :<=   ,  '@_less_eq',
+    :<    ,  '@_less',
+    :>    ,  '@_greater',
+    :>=   ,  '@_greater_eq',
+    :<=>  ,  '@_spaceship',
+    :==   ,  '@_2eq',
+    :===  ,  '@_3eq',
+    :!=   ,  '@_not_eq',
+    :=~   ,  '@_eq_tilde',
+    :!~   ,  '@_bang_tilde',
+  ].each_slice 2 do |method_name, ivar|
+    it "maps #{method_name} to #{ivar}" do
+      mocked_class.define method_name
+      instance = mocked_class.new
+      instance.instance_variable_set ivar, 123
+      instance.send method_name
+    end
+  end
+end

data/todo

@@ -2,16 +2,12 @@ Urgent (things I want to do immediately, formatted as the git commits I will use
 ---------------------------------------------------------------------------------
 
 * be smart enough to handle method missing
-* still check method args, even when value is overridden
 * tests around the error messages of types
 * Substitutability can check argument names
 * substitute_for should not depend on rspec-expectations
 * Error messages on blocks are actually useful
-* Defined methods params must match arguments (BREAKING CHANGE)
-* Update the readme (new syntax, and move the script into the changelog)
 * error message
     "Doesn't know initialize, only knows " <-- fix that shit
-* blocks assertions can specify raising
 
 TODO (next up after urgent, these will happen whenever I get around to it)
 --------------------------------------------------------------------------
@@ -20,13 +16,10 @@ TODO (next up after urgent, these will happen whenever I get around to it)
 * Remove dependency on all of RSpec and only depend on rspec-core, then have AC tests for the other shit
 * Add a better explanation for motivations
 * Figure out whether I'm supposed to be using clone or dup for the object -.^ (looks like there may also be an `initialize_copy` method I can take advantage of instead of crazy stupid shit I'm doing now)
-* don't blow up when delegating to the Object#initialize with args (do I still want this, or do I want to force arity matching (and maybe even variable name matching)?)
 * config: rspec_mocks loaded, whether unprepared blocks should raise or just return nil
 * extract surrogate/rspec into its own gem
-* support subset-substitutabilty not being able to touch real methods (e.g. #respond_to?)
 * make substitutability matcher go either way
 * make substitutability matcher not care whether either are surrogates
-* Add support for operators
 
 
 Future Features (Things that probably should eventually happen, but not anytime soon unless I get really inspired to work on this shit)
@@ -34,8 +27,7 @@ Future Features (Things that probably should eventually happen, but not anytime
 
 * Can endow a class multiple times, results aggregate instead of override
 * figure out how to talk about callbacks like #on_success
-* have some sort of reinitialization that can hook into setup/teardown steps of test suite
-* Support arity checking as part of substitutability
+* have some sort of reinitialization that can hook into setup/teardown steps of test suite (maybe, or maybe I'm happy with what I have)
 * Ability to disassociate the method name from the test (e.g. you shouldn't need to change a test just because you change a name)
 * ability to declare normal methods as being part of the API
 * ability to declare a define that uses the overridden method as the body, but can still act like an api method

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: surrogate
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-23 00:00:00.000000000 Z
+date: 2012-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70261539914140 !ruby/object:Gem::Requirement
+  requirement: &70147459182300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70261539914140
+  version_requirements: *70147459182300
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70261539929980 !ruby/object:Gem::Requirement
+  requirement: &70147459181540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.4'
   type: :development
   prerelease: false
-  version_requirements: *70261539929980
+  version_requirements: *70147459181540
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields
-  requirement: &70261539929360 !ruby/object:Gem::Requirement
+  requirement: &70147459180560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70261539929360
+  version_requirements: *70147459180560
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-rspec
-  requirement: &70261539928860 !ruby/object:Gem::Requirement
+  requirement: &70147459179620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70261539928860
+  version_requirements: *70147459179620
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-magic_comments
-  requirement: &70261539928300 !ruby/object:Gem::Requirement
+  requirement: &70147459178820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: 1.0.1
   type: :development
   prerelease: false
-  version_requirements: *70261539928300
+  version_requirements: *70147459178820
 description: Framework to aid in handrolling mock/spy objects.
 email:
 - josh.cheek@gmail.com
@@ -94,6 +94,7 @@ files:
 - lib/surrogate/porc_reflector.rb
 - lib/surrogate/rspec.rb
 - lib/surrogate/rspec/abstract_failure_message.rb
+- lib/surrogate/rspec/block_asserter.rb
 - lib/surrogate/rspec/initialization_matcher.rb
 - lib/surrogate/rspec/invocation_matcher.rb
 - lib/surrogate/rspec/noun_matcher.rb
@@ -120,6 +121,7 @@ files:
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb
 - spec/unit/argument_errorizer_spec.rb
+- spec/unit/map_method_name_to_ivar_spec.rb
 - surrogate.gemspec
 - todo
 homepage: https://github.com/JoshCheek/surrogate
@@ -161,4 +163,5 @@ test_files:
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb
 - spec/unit/argument_errorizer_spec.rb
+- spec/unit/map_method_name_to_ivar_spec.rb
 has_rdoc: