surrogate 0.5.5 → 0.6.0

data/spec/rspec/block_support_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 # these all need error messages
 describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
 
-  let(:dir)      { Surrogate.endow(Class.new) { define(:chdir) { nil }}}
+  let(:dir)      { Surrogate.endow(Class.new) { define(:chdir) { |dir_path| nil }}}
   let(:dir_path) { '/some/dir/path' }
 
   it 'fails if no submitted_blocks were found' do
@@ -57,7 +57,7 @@ describe 'RSpec matchers', 'have_been_told_to(...).with { |block| }' do
   end
 
 
-  let(:file)      { Surrogate.endow(Class.new) { define(:write) { true }}}
+  let(:file)      { Surrogate.endow(Class.new) { define(:write) { |name, body| true }}}
   let(:file_name) { 'some_file_name.ext' }
   let(:file_body) { 'some file body' }
 

data/spec/rspec/initialization_matcher_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe 'should/should_not have_been_initialized_with' do
-  let(:mocked_class) { Surrogate.endow Class.new }
-  before { mocked_class.module_eval { def initialize(*) end } } # b/c 1.9.3 will have arity issues otherwise
+  let(:mocked_class) { Surrogate.endow(Class.new).define(:initialize) { |*| } }
 
   it 'is the same as have_been_told_to(:initialize).with(...)' do
     mocked_class.new.should have_been_initialized_with no_args
@@ -26,11 +25,15 @@ describe 'should/should_not have_been_initialized_with' do
     failure_message_for { mocked_class.new("1").should_not have_been_initialized_with('1') }.should ==
       failure_message_for { mocked_class.new("1").should_not have_been_told_to(:initialize).with('1') }
   end
+
+  example "informs you when it wasn't defined" do
+    expect { Surrogate.endow(Class.new).new.should have_been_initialized_with no_args }
+      .to raise_error Surrogate::UnknownMethod
+  end
 end
 
 describe 'was/was_not initialized_with' do
-  let(:mocked_class) { Surrogate.endow Class.new }
-  before { mocked_class.module_eval { def initialize(*) end } } # b/c 1.9.3 will have arity issues otherwise
+  let(:mocked_class) { Surrogate.endow(Class.new).define(:initialize) { |*| } }
 
   it 'is the same as have_been_told_to(:initialize).with(...)' do
     mocked_class.new.was initialized_with no_args
@@ -54,4 +57,9 @@ describe 'was/was_not initialized_with' do
     failure_message_for { mocked_class.new("1").was_not initialized_with('1') }.should ==
       failure_message_for { mocked_class.new("1").was_not told_to(:initialize).with('1') }
   end
+
+  example "informs you when it wasn't defined" do
+    expect { Surrogate.endow(Class.new).new.was initialized_with no_args }
+      .to raise_error Surrogate::UnknownMethod
+  end
 end

data/spec/rspec/rspec_mocks_integration_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'integration with rspec-mocks' do
 
-  let(:mp3) { Surrogate.endow(Class.new).define(:play) { }.new }
+  let(:mp3) { Surrogate.endow(Class.new).define(:play) { |artist| }.new }
 
   it 'knows that rspec-mocks is loaded' do
     Surrogate::RSpec.rspec_mocks_loaded?.should equal true

data/spec/rspec/substitute_for_spec.rb

@@ -102,9 +102,9 @@ describe 'substitute_for' do
           surrogate = Surrogate.endow(Class.new) { define :surrogate_class_meth }.define :surrogate_instance_meth
           klass = Class.new { def self.api_class_meth()end; def api_instance_meth() end }
           expect { surrogate.should substitute_for klass }.to \
-            raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra instance methods: [:surrogate_instance_meth], "\
-                                                                                                             "has extra class methods: [:surrogate_class_meth], "\
-                                                                                                             "is missing instance methods: [:api_instance_meth], "\
+            raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra instance methods: [:surrogate_instance_meth]\n"\
+                                                                                                             "has extra class methods: [:surrogate_class_meth]\n"\
+                                                                                                             "is missing instance methods: [:api_instance_meth]\n"\
                                                                                                              "is missing class methods: [:api_class_meth]")
         end
 
@@ -145,7 +145,93 @@ describe 'substitute_for' do
         klass = Class.new { def self.extra_method()end; def extra_method()end }
         expect { Surrogate.endow(Class.new) { define :class_meth }.define(:instance_meth).should substitute_for klass, subset: true }.to \
           raise_error(RSpec::Expectations::ExpectationNotMetError,
-                      "Was not substitutable because surrogate has extra instance methods: [:instance_meth], has extra class methods: [:class_meth]")
+                      "Was not substitutable because surrogate has extra instance methods: [:instance_meth]\nhas extra class methods: [:class_meth]")
+      end
+    end
+  end
+
+
+
+  context 'type substitutability -- specified with types: true/false option (DEFAULTS TO TRUE)' do
+    it 'is turned on by default' do
+      klass = Class.new { def instance_meth(a) end }
+      surrogate = Surrogate.endow(Class.new).define(:instance_meth) { }
+      surrogate.should_not substitute_for klass
+      surrogate.should substitute_for klass, types: false
+    end
+
+    it 'disregards when argument names differ' do
+      klass = Class.new { def instance_meth(a) end }
+      surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |b| }
+      surrogate.should substitute_for klass, names: false, types: true
+    end
+
+    it 'disregards when surrogate has no body for an api method' do
+      klass = Class.new { def instance_meth(a) end }
+      surrogate = Surrogate.endow(Class.new).define :instance_meth
+      surrogate.should substitute_for klass, types: true
+    end
+
+    it 'disregards when real object has natively implemented methods that cannot be reflected on' do
+      Array.method(:[]).parameters.should == [[:rest]] # make sure Array signatures aren't changing across versions or something
+      Array.instance_method(:insert).parameters.should == [[:rest]]
+      surrogate = Surrogate.endow(Class.new) { define(:[]) { |a,b,c| } }.define(:insert) { |a,b,c| }
+      surrogate.should substitute_for Array, subset: true, types: true
+    end
+
+    context 'returns true if argument types match exactly. Examples:' do
+      example 'true when exact match' do
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should substitute_for klass, types: true
+      end
+
+      example 'false when missing block' do
+        klass = Class.new { def instance_meth(a, b=1, *c, d) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d| }
+        surrogate.should_not substitute_for klass, types: true
+      end
+
+      example 'false when missing splatted args' do
+        klass = Class.new { def instance_meth(a, b=1, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, d, &e| }
+        surrogate.should_not substitute_for klass
+      end
+
+      example 'false when missing optional args' do
+        klass = Class.new { def instance_meth(a, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass
+
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+      end
+
+      example 'false when missing required args' do
+        klass = Class.new { def instance_meth(b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+
+        klass = Class.new { def instance_meth(a, b=1, *c, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, d, &e| }
+        surrogate.should_not substitute_for klass, types: true
+
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth) { |a, b=1, *c, &e| }
+        surrogate.should_not substitute_for klass, types: true
       end
     end
   end

data/spec/unit/api_comparer_spec.rb

@@ -3,33 +3,47 @@ require 'spec_helper'
 describe Surrogate::ApiComparer do
 
   def set_assertion(set, expectations)
-    expectations[:include].each { |meth| set.should include meth }
-    expectations[:exclude].each { |meth| set.should_not include meth }
+    Array(expectations[:include]).each { |meth| set.should include meth }
+    Array(expectations[:exclude]).each { |meth| set.should_not include meth }
   end
 
+  context 'when identifying types' do
+    it 'uses :req, :opt, :rest, and :block' do
+      surrogate = Surrogate.endow(Class.new).define(:to_s) { |a, b, c, d=1, e=2, *f, g, &h| }
+      comparer = described_class.new(surrogate, Class.new)
+      comparer.compare[:instance][:types][:to_s][:surrogate].should ==
+        [:req, :req, :req, :opt, :opt, :rest, :req, :block]
+    end
+  end
 
   describe 'its knowlege about the surrogate' do
 
     let :surrogate do
       parent = Class.new do
         def inherited_instance_meth()end
+        def inherited_instance_meth_with_signature(a1, b1=1, *c1, d1, &e1)end
         def self.inherited_class_meth()end
+        def self.inherited_class_meth_with_signature(a2, b2=1, *c2, d2, &e2)end
       end
 
       Class.new parent do
         Surrogate.endow self do
           define :api_class_meth
+          define(:api_class_meth_with_signature) { |a3, b3=1, *c3, d3, &e3| }
           def class_meth()end
+          def self.class_meth_with_signature(a4, b4=1, *c4, d4, &e4)end
         end
         define :api_instance_meth
+        define(:api_instance_meth_with_signature) { |a5, b5=1, *c5, d5, &e5| }
         def instance_meth()end
+        def instance_meth_with_signature(a6, b6=1, *c6, d6, &e6)end
       end
     end
 
     let(:comparer) { described_class.new surrogate, Class.new }
 
     it "knows the surrogate's instance level api methods" do
-      comparer.surrogate_methods[:instance][:api].should == Set[:api_instance_meth]
+      comparer.surrogate_methods[:instance][:api].should == Set[:api_instance_meth, :api_instance_meth_with_signature]
     end
 
     it "knows the surrogate's inherited instance methods" do
@@ -45,7 +59,7 @@ describe Surrogate::ApiComparer do
     end
 
     it "knows the surrogate's class level api methods" do
-      comparer.surrogate_methods[:class][:api].should == Set[:api_class_meth]
+      comparer.surrogate_methods[:class][:api].should == Set[:api_class_meth, :api_class_meth_with_signature]
     end
 
     it "knows the surrogate's inherited class methods" do
@@ -134,5 +148,107 @@ describe Surrogate::ApiComparer do
     it 'tells me about api class methods on surrogate that are not on actual' do
       comparer.compare[:class][:not_on_actual].should == Set[:class_not_on_actual]
     end
+
+
+    context "it tells me the difference when types don't match. Examples:" do
+      example 'nothing when arguments are the same' do
+        klass = Class.new do
+          def self.class_meth1(a1, b1=1, *c1, &d1)end
+          def self.class_meth2(a2, b2=1, *c2, &d2)end
+          def self.class_meth3(a3, b3=1, *c3, &d3)end
+          def instance_meth1(e1, f1=1, *c1, &d1)end
+          def instance_meth2(e2, f2=1, *c2, &d2)end
+          def instance_meth3(e3, f3=1, *c3, &d3)end
+        end
+
+        parent = Class.new do
+          def self.class_meth1(a1, b1=1, *c1, &d1)end
+          def instance_meth1(e1, f1=1, *c1, &d1)end
+        end
+
+        surrogate = Class.new parent do
+          Surrogate.endow self do
+            define(:class_meth2) { |a2, b2=1, *c2, &d2| }
+          end
+          def self.class_meth3(a3, b3=1, *c3, &d3)end
+          define(:instance_meth2) { |e2, f2=1, *c2, &d2| }
+          def instance_meth3(e3, f3=1, *c3, &d3)end
+        end
+
+        comparer = described_class.new surrogate, klass
+        comparer.compare[:instance][:types].should  == {}
+        comparer.compare[:class][:types].should == {}
+      end
+
+      it 'ignores methods that are not on both the surrogate and the actual' do
+        klass = Class.new do
+          def self.class_meth1(a)end
+          def instance_meth1(a, b)end
+        end
+        surrogate = Class.new do
+          Surrogate.endow self do
+            define(:class_meth2) { |a, b, c| }
+          end
+          define(:instance_meth2) { |a, b, c, d| }
+        end
+
+        described_class.new(surrogate, klass).compare
+        comparer.compare[:class][:types].should == {}
+        comparer.compare[:instance][:types].should == {}
+      end
+
+      it 'ignores methods with no default block' do
+        klass = Class.new { def instance_meth(a)end }
+        surrogate = Surrogate.endow(Class.new).define(:instance_meth)
+        described_class.new(surrogate, klass).compare
+        comparer.compare[:class][:types].should == {}
+        comparer.compare[:instance][:types].should == {}
+      end
+
+      it 'tells me about class methods with different types' do
+        klass = Class.new do
+          def self.class_meth1(a, b=1, *c, &d)end
+          def self.class_meth2(a, b=1, *c, &d)end
+        end
+        parent = Class.new { def self.class_meth1(b=1, *c, &d)end }
+        surrogate = Class.new parent do
+          Surrogate.endow self do
+            define(:class_meth2) { |a, *c, &d| }
+          end
+        end
+
+        comparer = described_class.new surrogate, klass
+        comparer.compare[:class][:types].should == {
+          class_meth1: { actual:    [:req, :opt, :rest, :block],
+                         surrogate: [      :opt, :rest, :block],
+          },
+          class_meth2: { actual:    [:req, :opt, :rest, :block],
+                         surrogate: [:req,       :rest, :block],
+          },
+        }
+      end
+
+      it 'tells me about class methods with different types' do
+        klass = Class.new do
+          def instance_meth1(a, b=1, *c, &d)end
+          def instance_meth2(a, b=1, *c, &d)end
+        end
+        parent = Class.new { def instance_meth1(b=1, *c, &d)end }
+        surrogate = Class.new parent do
+          Surrogate.endow self
+          define(:instance_meth2) { |a, *c, &d| }
+        end
+
+        comparer = described_class.new surrogate, klass
+        comparer.compare[:instance][:types].should == {
+          instance_meth1: { actual:    [:req, :opt, :rest, :block],
+                            surrogate: [      :opt, :rest, :block],
+          },
+          instance_meth2: { actual:    [:req, :opt, :rest, :block],
+                            surrogate: [:req,       :rest, :block],
+          },
+        }
+      end
+    end
   end
 end

data/spec/unit/argument_errorizer_spec.rb

@@ -0,0 +1,50 @@
+require 'surrogate/argument_errorizer'
+
+describe Surrogate::ArgumentErrorizer do
+  let(:meth_name) { :some_name }
+
+  describe 'match!' do
+    it 'raises an argument error if the arguments do not match' do
+      expect { described_class.new(meth_name, ->(){}).match! 1 }.to raise_error ArgumentError
+    end
+
+    it 'does not raise any errors if the arguments do match' do
+      described_class.new(meth_name, ->(){}).match!
+    end
+
+    it 'does not execute the actual lambda' do
+      described_class.new(meth_name, ->{ raise }).match!
+    end
+
+    it 'cares about required, optional, and block arguments' do
+      errorizer = described_class.new meth_name, ->(a, b=1, c, &d){}
+      expect { errorizer.match!   }.to raise_error ArgumentError
+      expect { errorizer.match! 1 }.to raise_error ArgumentError
+      errorizer.match! 1, 2
+      errorizer.match! 1, 2, 3
+      expect { errorizer.match! 1, 2, 3, 4 }.to raise_error ArgumentError
+
+      errorizer = described_class.new meth_name, ->(a, b=1, *c, d, &e){}
+      errorizer.match! *1..10
+    end
+
+    it 'does not care whether the block was provided' do
+      described_class.new(meth_name, ->(&b){}).match!
+    end
+  end
+
+  def assert_message(the_lambda, args, message)
+    expect { described_class.new(meth_name, the_lambda).match! *args }
+      .to raise_error ArgumentError, message
+  end
+
+  it 'has useful error messages' do
+    assert_message ->(){},                           [1],   "wrong number of arguments (1 for 0) in #{meth_name}()"
+    assert_message ->(a){},                          [],    "wrong number of arguments (0 for 1) in #{meth_name}(a)"
+    assert_message ->(a){},                          [],    "wrong number of arguments (0 for 1) in #{meth_name}(a)"
+    assert_message ->(a=1){},                        [1,2], "wrong number of arguments (2 for 1) in #{meth_name}(a='?')"
+    assert_message ->(a, *b){},                      [],    "wrong number of arguments (0 for 1) in #{meth_name}(a, *b)"
+    assert_message ->(a, *b, &c){},                  [],    "wrong number of arguments (0 for 1) in #{meth_name}(a, *b, &c)"
+    assert_message ->(a, b, c=1, d=1, *e, f, &g){},  [],    "wrong number of arguments (0 for 3) in #{meth_name}(a, b, c='?', d='?', *e, f, &g)"
+  end
+end

data/surrogate.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'bindable_block', '= 0.0.5.1'
-
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec",                                "~> 2.4"
   s.add_development_dependency "mountain_berry_fields",                "~> 1.0.3"

data/todo

@@ -0,0 +1,44 @@
+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)
+--------------------------------------------------------------------------
+
+* Eventually it should be smart enough to not ignore natively implemented code with a [[:req]] argument
+* 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)
+---------------------------------------------------------------------------------------------------------------------------------------
+
+* 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
+* 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
+* assertions for order of invocations & methods
+* class generator? (supports a top-down style of development for when you write your mocks before you write your implementations)
+* deal with hard dependency on rspec-mocks

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: surrogate
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2012-09-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bindable_block
-  requirement: &70355417643520 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - =
-      - !ruby/object:Gem::Version
-        version: 0.0.5.1
-  type: :runtime
-  prerelease: false
-  version_requirements: *70355417643520
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70355417643100 !ruby/object:Gem::Requirement
+  requirement: &70261539914140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70355417643100
+  version_requirements: *70261539914140
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70355417642540 !ruby/object:Gem::Requirement
+  requirement: &70261539929980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +32,10 @@ dependencies:
         version: '2.4'
   type: :development
   prerelease: false
-  version_requirements: *70355417642540
+  version_requirements: *70261539929980
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields
-  requirement: &70355417642020 !ruby/object:Gem::Requirement
+  requirement: &70261539929360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +43,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70355417642020
+  version_requirements: *70261539929360
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-rspec
-  requirement: &70355417641540 !ruby/object:Gem::Requirement
+  requirement: &70261539928860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +54,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70355417641540
+  version_requirements: *70261539928860
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-magic_comments
-  requirement: &70355417641080 !ruby/object:Gem::Requirement
+  requirement: &70261539928300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +65,7 @@ dependencies:
         version: 1.0.1
   type: :development
   prerelease: false
-  version_requirements: *70355417641080
+  version_requirements: *70261539928300
 description: Framework to aid in handrolling mock/spy objects.
 email:
 - josh.cheek@gmail.com
@@ -87,6 +76,7 @@ files:
 - .gitignore
 - .rvmrc
 - .travis.yml
+- Changelog.md
 - Rakefile
 - Readme.md
 - Readme.md.mountain_berry_fields
@@ -95,11 +85,13 @@ files:
 - gemfiles/rspec_mocks_2.2
 - lib/surrogate.rb
 - lib/surrogate/api_comparer.rb
+- lib/surrogate/argument_errorizer.rb
 - lib/surrogate/endower.rb
 - lib/surrogate/hatchery.rb
 - lib/surrogate/hatchling.rb
 - lib/surrogate/invocation.rb
-- lib/surrogate/options.rb
+- lib/surrogate/method_definition.rb
+- lib/surrogate/porc_reflector.rb
 - lib/surrogate/rspec.rb
 - lib/surrogate/rspec/abstract_failure_message.rb
 - lib/surrogate/rspec/initialization_matcher.rb
@@ -110,6 +102,8 @@ files:
 - lib/surrogate/rspec/times_predicate.rb
 - lib/surrogate/rspec/verb_matcher.rb
 - lib/surrogate/rspec/with_filter.rb
+- lib/surrogate/surrogate_class_reflector.rb
+- lib/surrogate/surrogate_instance_reflector.rb
 - lib/surrogate/values.rb
 - lib/surrogate/version.rb
 - spec/acceptance_spec.rb
@@ -125,7 +119,9 @@ files:
 - spec/rspec/verb_matcher_spec.rb
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb
+- spec/unit/argument_errorizer_spec.rb
 - surrogate.gemspec
+- todo
 homepage: https://github.com/JoshCheek/surrogate
 licenses: []
 post_install_message: 
@@ -164,4 +160,5 @@ test_files:
 - spec/rspec/verb_matcher_spec.rb
 - spec/spec_helper.rb
 - spec/unit/api_comparer_spec.rb
+- spec/unit/argument_errorizer_spec.rb
 has_rdoc: