surrogate 0.6.1 → 0.6.2

data/Changelog.md

@@ -1,3 +1,10 @@
+### 0.6.2
+
+* Make substitutability matcher go either way (you should now do `RealClass.should substitute_for SurrogateClass` eventually, doing it in the other direction will not be supported)
+* Bug fix: checks arity on invocations, even when default value is overridden
+* Substitutability can check argument names
+* Fix error message when there are no api methods. Used to say "Doesn't know initialize, only knows "
+
 ### 0.6.1
 
 * bang methods map to ivars suffixed with `_b`, because you can't have a bang in an ivar name

data/Readme.md

@@ -327,7 +327,7 @@ Assert that your mock has the **same interface** as your real class.
 This will fail if the mock inherits methods which are not on the real class. It will also fail
 if the real class has any methods which have not been defined on the mock or inherited by the mock.
 
-Presently, it will ignore methods defined directly in the mock (as it generally considers them to be helpers).
+Presently, it will ignore methods defined directly in the mock (as it considers them to be helpers).
 In a future version, you will be able to tell it to treat other methods
 as part of the API (will fail if they don't match, and maybe record their values).
 
@@ -344,30 +344,25 @@ class MockUser
 end
 
 # they are the same
-MockUser.should substitute_for User
+User.should substitute_for MockUser
 
-# mock has extra method
+# they differ
 MockUser.define :name
-MockUser.should_not substitute_for User
+User.should_not substitute_for MockUser
 
-# the same again via inheritance
-class UserWithName < User
-  def name()end
-end
-MockUser.should substitute_for UserWithName
-
-# real class has extra methods
-class UserWithNameAndAddress < UserWithName
-  def address()end
-end
-MockUser.should_not substitute_for UserWithNameAndAddress
-
-# signatures don't match
+# signatures don't match (you can turn this off by passing `types: false` to substitute_for)
 class UserWithWrongSignature
   def initialize()end # no id
   def id()end
 end
-MockUser.should_not substitute_for UserWithWrongSignature
+UserWithWrongSignature.should_not substitute_for MockUser
+
+# parameter names don't match
+class UserWithWrongParamNames
+  def initialize(name)end # real one takes an id
+  def id()end
+end
+UserWithWrongParamNames.should_not substitute_for MockUser, names: true
 ```
 
 Sometimes you don't want to have to implement the entire interface.
@@ -388,11 +383,11 @@ class MockUser
 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
+User.should substitute_for MockUser, subset: true
 
 # but now it fails b/c it has no address
 MockUser.define :address
-MockUser.should_not substitute_for User, subset: true
+User.should_not substitute_for MockUser, subset: true
 ```
 
 

data/Readme.md.mountain_berry_fields

@@ -411,7 +411,7 @@ Assert that your mock has the **same interface** as your real class.
 This will fail if the mock inherits methods which are not on the real class. It will also fail
 if the real class has any methods which have not been defined on the mock or inherited by the mock.
 
-Presently, it will ignore methods defined directly in the mock (as it generally considers them to be helpers).
+Presently, it will ignore methods defined directly in the mock (as it considers them to be helpers).
 In a future version, you will be able to tell it to treat other methods
 as part of the API (will fail if they don't match, and maybe record their values).
 
@@ -429,30 +429,25 @@ class MockUser
 end
 
 # they are the same
-MockUser.should substitute_for User
+User.should substitute_for MockUser
 
-# mock has extra method
+# they differ
 MockUser.define :name
-MockUser.should_not substitute_for User
+User.should_not substitute_for MockUser
 
-# the same again via inheritance
-class UserWithName < User
-  def name()end
-end
-MockUser.should substitute_for UserWithName
-
-# real class has extra methods
-class UserWithNameAndAddress < UserWithName
-  def address()end
-end
-MockUser.should_not substitute_for UserWithNameAndAddress
-
-# signatures don't match
+# signatures don't match (you can turn this off by passing `types: false` to substitute_for)
 class UserWithWrongSignature
   def initialize()end # no id
   def id()end
 end
-MockUser.should_not substitute_for UserWithWrongSignature
+UserWithWrongSignature.should_not substitute_for MockUser
+
+# parameter names don't match
+class UserWithWrongParamNames
+  def initialize(name)end # real one takes an id
+  def id()end
+end
+UserWithWrongParamNames.should_not substitute_for MockUser, names: true
 <% end %>
 ```
 
@@ -475,11 +470,11 @@ class MockUser
 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
+User.should substitute_for MockUser, subset: true
 
 # but now it fails b/c it has no address
 MockUser.define :address
-MockUser.should_not substitute_for User, subset: true
+User.should_not substitute_for MockUser, subset: true
 <% end %>
 ```
 

data/lib/surrogate/api_comparer.rb

@@ -8,7 +8,11 @@ class Surrogate
   class ApiComparer
     attr_accessor :surrogate, :actual
 
-    def initialize(surrogate, actual)
+    def initialize(actual, surrogate)
+      unless surrogate.instance_variable_get(:@hatchery).kind_of?(Hatchery) && surrogate.instance_variable_get(:@hatchling).kind_of?(Hatchling)
+        Kernel.warn "You said #{actual} should substitute for #{surrogate}`, but as of 0.6.2, this should be asserted in the other direction."
+        surrogate, actual = actual, surrogate
+      end
       self.surrogate, self.actual = surrogate, actual
     end
 
@@ -26,11 +30,13 @@ class Surrogate
           not_on_surrogate: instance_not_on_surrogate,
           not_on_actual:    instance_not_on_actual,
           types:            instance_types,
+          names:            instance_names,
         },
         class: {
           not_on_surrogate: class_not_on_surrogate,
           not_on_actual:    class_not_on_actual,
           types:            class_types,
+          names:            class_names,
         },
       }
     end
@@ -53,11 +59,12 @@ class Surrogate
       surrogate_methods[:class][:api] - actual_methods[:class][:inherited] - actual_methods[:class][:other]
     end
 
+
+    # there is a lot of duplication in these next four methods -.-
+    # idk if there is something we can do about it.
+
     # types are only shown for methods on both objects
     def class_types
-      surrogate_class_methods         = surrogate_methods[:class][:api] + surrogate_methods[:class][:inherited]
-      actual_class_methods            = actual_methods[:class][:inherited] + actual_methods[:class][:other]
-      class_methods_that_should_match = (surrogate_class_methods & actual_class_methods) - surrogate_methods[:class][:without_bodies] - actual_methods[:class][:without_bodies]
       class_methods_that_should_match.each_with_object Hash.new do |name, hash|
         surrogate_type, actual_type = class_types_for name
         next if surrogate_type == actual_type
@@ -67,9 +74,6 @@ class Surrogate
 
     # types are only shown for methods on both objects
     def instance_types
-      surrogate_instance_methods         = surrogate_methods[:instance][:api] + surrogate_methods[:instance][:inherited]
-      actual_instance_methods            = actual_methods[:instance][:inherited] + actual_methods[:instance][:other]
-      instance_methods_that_should_match = (surrogate_instance_methods & actual_instance_methods) - surrogate_methods[:instance][:without_bodies] - actual_methods[:instance][:without_bodies]
       instance_methods_that_should_match.each_with_object Hash.new do |name, hash|
         surrogate_type, actual_type = instance_types_for name
         next if surrogate_type == actual_type
@@ -77,8 +81,41 @@ class Surrogate
       end
     end
 
+    # names are only shown for methods on both objects
+    def class_names
+      class_methods_that_should_match.each_with_object Hash.new do |method_name, hash|
+        surrogate_name, actual_name = class_parameter_names_for method_name
+        next if surrogate_name == actual_name
+        hash[method_name] = { surrogate: surrogate_name, actual: actual_name }
+      end
+    end
+
+    # names are only shown for methods on both objects
+    def instance_names
+      instance_methods_that_should_match.each_with_object Hash.new do |method_name, hash|
+        surrogate_name, actual_name = instance_parameter_names_for method_name
+        next if surrogate_name == actual_name
+        hash[method_name] = { surrogate: surrogate_name, actual: actual_name }
+      end
+    end
+
     private
 
+    def instance_methods_that_should_match
+      surrogate_instance_methods         = surrogate_methods[:instance][:api] + surrogate_methods[:instance][:inherited]
+      actual_instance_methods            = actual_methods[:instance][:inherited] + actual_methods[:instance][:other]
+      instance_methods_that_should_match = (surrogate_instance_methods & actual_instance_methods) - surrogate_methods[:instance][:without_bodies] - actual_methods[:instance][:without_bodies]
+    end
+
+    def class_methods_that_should_match
+      surrogate_class_methods         = surrogate_methods[:class][:api] + surrogate_methods[:class][:inherited]
+      actual_class_methods            = actual_methods[:class][:inherited] + actual_methods[:class][:other]
+      (surrogate_class_methods & actual_class_methods) - surrogate_methods[:class][:without_bodies] - actual_methods[:class][:without_bodies]
+    end
+
+    # there is a lot of duplication in these next four methods -.-
+    # also, it seems like a lot of this shit could move into the reflectors
+
     def class_types_for(name)
       surrogate_method = class_api_method_for name
       surrogate_method &&= to_lambda surrogate_method
@@ -95,10 +132,30 @@ class Surrogate
       return type_for(surrogate_method), type_for(actual_method)
     end
 
+    def class_parameter_names_for(name)
+      surrogate_method = class_api_method_for name
+      surrogate_method &&= to_lambda surrogate_method
+      surrogate_method ||= surrogate.method name
+      actual_method = actual.method name
+      return parameter_names_for(surrogate_method), parameter_names_for(actual_method)
+    end
+
+    def instance_parameter_names_for(name)
+      surrogate_method = instance_api_method_for name
+      surrogate_method &&= to_lambda surrogate_method
+      surrogate_method ||= surrogate.instance_method name
+      actual_method = actual.instance_method name
+      return parameter_names_for(surrogate_method), parameter_names_for(actual_method)
+    end
+
     def type_for(method)
       method.parameters.map(&:first)
     end
 
+    def parameter_names_for(method)
+      method.parameters.map(&:last)
+    end
+
     def to_lambda(proc)
       obj = Object.new
       obj.singleton_class.send :define_method, :abc123, &proc

data/lib/surrogate/argument_errorizer.rb

@@ -6,6 +6,7 @@ class Surrogate
     attr_accessor :name, :empty_lambda
 
     def initialize(name, lambda_or_method)
+      must_be_lambda_or_method lambda_or_method
       self.name, self.empty_lambda = name.to_s, lambda_with_same_params_as(lambda_or_method)
     end
 
@@ -39,5 +40,11 @@ class Surrogate
         raise "forgot to account for #{type.inspect}"
       end
     end
+
+    def must_be_lambda_or_method(lambda_or_method)
+      return if lambda_or_method.kind_of? ::Method
+      return if lambda_or_method.kind_of?(Proc) && lambda_or_method.lambda?
+      raise ArgumentError, "Expected a lambda or method, got a #{lambda_or_method.class}"
+    end
   end
 end

data/lib/surrogate/hatchling.rb

@@ -54,8 +54,13 @@ class Surrogate
 
     def must_know(method_name)
       return if api_methods.has_key? method_name
-      known_methods = api_methods.keys.map(&:to_s).map(&:inspect).join ', '
-      raise UnknownMethod, "doesn't know \"#{method_name}\", only knows #{known_methods}"
+      if api_methods.empty?
+        message = "doesn't know \"#{method_name}\", doesn't know anything! It's an epistemological conundrum, go define #{method_name}."
+      else
+        known_methods = api_methods.keys.map(&:to_s).map(&:inspect).join ', '
+        message = "doesn't know \"#{method_name}\", only knows #{known_methods}"
+      end
+      raise UnknownMethod, message
     end
 
     # maybe these ivar methods should be extracted into their own class

data/lib/surrogate/method_definition.rb

@@ -39,7 +39,7 @@ class Surrogate
     private
 
     def errorizer
-      @errorizer ||= ArgumentErrorizer.new name, default_proc
+      @errorizer ||= ArgumentErrorizer.new name, to_method_definition(default_proc)
     end
 
     def default_proc_as_method_on(instance)
@@ -50,6 +50,12 @@ class Surrogate
       klass.__send__ :remove_method, unique_name
       as_method.bind instance
     end
+
+    def to_method_definition(default_proc)
+      object = Object.new
+      object.define_singleton_method(:temp_method, &default_proc)
+      object.method(:temp_method)
+    end
   end
 end
 

data/lib/surrogate/rspec/substitute_for.rb

@@ -1,11 +1,13 @@
 class Surrogate
+  # turn this into a real class
   ::RSpec::Matchers.define :substitute_for do |original_class, options={}|
 
     comparison  = nil
     subset_only = options[:subset]
     types       = options.fetch :types, true
+    names       = options.fetch :names, false
 
-    def comparing_fields(comparison, subset_only, types)
+    def comparing_fields(comparison, subset_only, types, names)
       fields = {}
       fields[:instance_not_on_actual   ] = comparison[:instance][:not_on_actual]
       fields[:class_not_on_actual      ] = comparison[:class   ][:not_on_actual]
@@ -13,21 +15,25 @@ class Surrogate
       fields[:class_not_on_surrogate   ] = comparison[:class   ][:not_on_surrogate] unless subset_only
       fields[:instance_types           ] = comparison[:instance][:types]            if types
       fields[:class_types              ] = comparison[:class   ][:types]            if types
+      fields[:instance_names           ] = comparison[:instance][:names]            if names
+      fields[:class_names              ] = comparison[:class   ][:names]            if names
       fields
     end
 
     match do |mocked_class|
       comparison = ApiComparer.new(mocked_class, original_class).compare
-      comparing_fields(comparison, subset_only, types).values.inject(:+).empty?
+      comparing_fields(comparison, subset_only, types, names).values.inject(:+).empty?
     end
 
     failure_message_for_should do
-      extra_instance_methods   = comparison[:instance][:not_on_actual   ].to_a
+      extra_instance_methods   = comparison[:instance][:not_on_actual   ].to_a # these come in as sets
       extra_class_methods      = comparison[:class   ][:not_on_actual   ].to_a
       missing_instance_methods = comparison[:instance][:not_on_surrogate].to_a
       missing_class_methods    = comparison[:class   ][:not_on_surrogate].to_a
       instance_type_mismatch   = comparison[:instance][:types           ]
       class_type_mismatch      = comparison[:class   ][:types           ]
+      instance_name_mismatch   = comparison[:instance][:names           ]
+      class_name_mismatch      = comparison[:class   ][:names           ]
 
 
       differences = []
@@ -40,6 +46,11 @@ class Surrogate
         instance_type_mismatch.each { |name, types| differences << "##{name} had types #{types.inspect}" }
         class_type_mismatch.each    { |name, types| differences << ".#{name} had types #{types.inspect}" }
       end
+
+      if names # this conditional is not tested, nor are these error messages
+        instance_name_mismatch.each { |method_name, param_names| differences << "##{method_name} had parameter names #{param_names.inspect}" }
+        class_type_mismatch.each    { |method_name, param_names| differences << ".#{method_name} had parameter names #{param_names.inspect}" }
+      end
       "Was not substitutable because surrogate " << differences.join("\n")
     end
 

data/lib/surrogate/version.rb

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

data/spec/acceptance_spec.rb

@@ -107,12 +107,12 @@ describe Surrogate do
     # pass the error as the return value, it will be raised when method is invoked
     error = StandardError.new("some message")
     user.will_add_phone_number error
-    expect { user.add_phone_number }.to raise_error StandardError, "some message"
+    expect { user.add_phone_number '312', '123-4567' }.to raise_error StandardError, "some message"
 
     # =====  Substitutability  =====
 
     # real user is not a suitable substitute if missing methods that mock user has
-    user_class.should_not substitute_for Class.new
+    Class.new.should_not substitute_for user_class
 
     # real user must have all of mock user's methods to be substitutable
     substitutable_real_user_class = Class.new do
@@ -124,22 +124,22 @@ describe Surrogate do
       def phone_numbers() end
       def add_phone_number(area_code, number) end
     end
-    user_class.should substitute_for substitutable_real_user_class
-    user_class.should substitute_for substitutable_real_user_class, subset: true
+    substitutable_real_user_class.should substitute_for user_class
+    substitutable_real_user_class.should substitute_for user_class, subset: true
 
     # when real user class has extra methods, it is only substitutable as a subset
     real_user_class = substitutable_real_user_class.clone
     def real_user_class.some_class_meth() end
-    user_class.should_not substitute_for real_user_class
+    real_user_class.should_not substitute_for user_class
 
     real_user_class = substitutable_real_user_class.dup
     real_user_class.send(:define_method, :some_instance_method) {}
-    user_class.should_not substitute_for real_user_class
-    user_class.should substitute_for real_user_class, subset: true
+    real_user_class.should_not substitute_for user_class
+    real_user_class.should substitute_for user_class, subset: true
 
     # subset substitutability does not work for superset
     real_user_class = substitutable_real_user_class.dup
     real_user_class.send :undef_method, :address
-    user_class.should_not substitute_for real_user_class, subset: true
+    real_user_class.should_not substitute_for user_class, subset: true
   end
 end

data/spec/defining_api_methods_spec.rb

@@ -99,6 +99,8 @@ describe 'define' do
         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")
+          expect { Surrogate.endow(Class.new).new.will_override :whateva, 123 }
+            .to raise_error Surrogate::UnknownMethod, %[doesn't know "whateva", doesn't know anything! It's an epistemological conundrum, go define whateva.]
         end
       end
 

data/spec/rspec/initialization_matcher_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe 'should/should_not have_been_initialized_with' do
+describe 'was initialized_with' do
   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
-    mocked_class.new.should_not have_been_initialized_with(1)
-    mocked_class.new(1).should have_been_initialized_with 1
-    mocked_class.new(1, '2').should have_been_initialized_with 1, '2'
+  it 'is the same as told_to(:initialize).with(...)' do
+    mocked_class.new.was initialized_with no_args
+    mocked_class.new.was_not initialized_with(1)
+    mocked_class.new(1).was initialized_with 1
+    mocked_class.new(1, '2').was initialized_with 1, '2'
   end
 
   def failure_message_for
@@ -17,17 +17,17 @@ describe 'should/should_not have_been_initialized_with' do
   end
 
   example 'failure message for should' do
-    failure_message_for { mocked_class.new("1").should have_been_initialized_with 2 }.should ==
-      failure_message_for { mocked_class.new("1").should have_been_told_to(:initialize).with(2) }
+    failure_message_for { mocked_class.new("1").was initialized_with 2 }.should ==
+      failure_message_for { mocked_class.new("1").was told_to(:initialize).with(2) }
   end
 
   example 'failure message for should not' 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') }
+    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.should have_been_initialized_with no_args }
+    expect { Surrogate.endow(Class.new).new.was initialized_with no_args }
       .to raise_error Surrogate::UnknownMethod
   end
 end
@@ -35,7 +35,7 @@ end
 describe 'was/was_not initialized_with' do
   let(:mocked_class) { Surrogate.endow(Class.new).define(:initialize) { |*| } }
 
-  it 'is the same as have_been_told_to(:initialize).with(...)' do
+  it 'is the same as told_to(:initialize).with(...)' do
     mocked_class.new.was initialized_with no_args
     mocked_class.new.was_not initialized_with 1
     mocked_class.new(1).was initialized_with 1
@@ -54,8 +54,8 @@ describe 'was/was_not initialized_with' do
   end
 
   example 'failure message for should not' 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') }
+    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

data/spec/rspec/substitute_for_spec.rb

@@ -1,31 +1,47 @@
 require 'spec_helper'
 
 describe 'substitute_for' do
+  context 'understands that the non-surrogate class should substitute for the surrogate class when' do
+    specify 'the surrogate class comes first (but it does emit a warning)' do
+      Kernel.should_receive(:warn).twice.with kind_of String
+      surrogate = Surrogate.endow(Class.new).define(:some_meth)
+      surrogate.should_not substitute_for Class.new
+      surrogate.should substitute_for Class.new { def some_meth() end }
+    end
+
+    it 'the non-surrogate class comes first (and it does not emit a warning)' do
+      Kernel.should_not_receive :warn
+      surrogate = Surrogate.endow(Class.new).define(:some_meth)
+      Class.new.should_not substitute_for surrogate
+      Class.new { def some_meth() end }.should substitute_for surrogate
+    end
+  end
+
   context 'exact substitutability' do
     context "returns true iff api methods and inherited methods match exactly to the other object's methods. Examples:" do
       context "a surrogate with no api methods" do
         let(:surrogate) { Surrogate.endow Class.new }
 
         example "is substitutable for a class with no methods" do
-          surrogate.should substitute_for Class.new
+          Class.new.should substitute_for surrogate
         end
 
         example "is not substitutable for a class with instance methods" do
-          surrogate.should_not substitute_for Class.new { def foo()end }
+          Class.new { def foo()end }.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with class methods" do
-          surrogate.should_not substitute_for Class.new { def self.foo()end }
+          Class.new { def self.foo()end }.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with inherited instance methods" do
           parent = Class.new { def foo()end }
-          surrogate.should_not substitute_for Class.new(parent)
+          Class.new(parent).should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with inherited class methods" do
           parent = Class.new { def self.foo()end }
-          surrogate.should_not substitute_for Class.new(parent)
+          Class.new(parent).should_not substitute_for surrogate
         end
       end
 
@@ -34,39 +50,39 @@ describe 'substitute_for' do
         let(:surrogate) { Class.new { Surrogate.endow self; define :foo } }
 
         example "is substitutable for a class with the same method" do
-          surrogate.should substitute_for Class.new { def foo()end }
+          Class.new { def foo()end }.should substitute_for surrogate
         end
 
         example "is substitutable for a class that inherits the method" do
           parent = Class.new { def foo()end }
-          surrogate.should substitute_for Class.new(parent)
+          Class.new(parent).should substitute_for surrogate
         end
 
         example "is not substitutable for a class without the method" do
-          surrogate.should_not substitute_for Class.new
+          Class.new.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with a different method" do
-          surrogate.should_not substitute_for Class.new { def bar()end }
+          Class.new { def bar()end }.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with additional methods" do
           other = Class.new { def foo()end; def bar()end }
-          surrogate.should_not substitute_for other
+          other.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with the method and inerited additional methods" do
           parent = Class.new { def bar()end }
-          surrogate.should_not substitute_for Class.new(parent) { def foo()end }
+          Class.new(parent) { def foo()end }.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with the method and additional class methods" do
-          surrogate.should_not substitute_for Class.new { def foo()end; def self.bar()end }
+          Class.new { def foo()end; def self.bar()end }.should_not substitute_for surrogate
         end
 
         example "is not substitutable for a class with the method and inherited additional class methods" do
           parent = Class.new { def self.bar()end }
-          surrogate.should_not substitute_for Class.new(parent) { def foo()end }
+          Class.new(parent) { def foo()end }.should_not substitute_for surrogate
         end
       end
 
@@ -76,32 +92,32 @@ describe 'substitute_for' do
 
         specify 'when klass is missing an instance method' do
           surrogate.define :meth
-          expect { surrogate.should substitute_for Class.new }.to \
+          expect { Class.new.should substitute_for surrogate }.to \
             raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra instance methods: [:meth]")
         end
 
         specify 'when klass is missing a class method' do
           surrogate = Surrogate.endow(Class.new) { define :meth }
-          expect { surrogate.should substitute_for Class.new }.to \
+          expect { Class.new.should substitute_for surrogate }.to \
             raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra class methods: [:meth]")
         end
 
         specify 'when surrogate is missing an instance method' do
           klass = Class.new { def meth() end }
-          expect { surrogate.should substitute_for klass }.to \
+          expect { klass.should substitute_for surrogate }.to \
             raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate is missing instance methods: [:meth]")
         end
 
         specify 'when surrogate is missing a class method' do
           klass = Class.new { def self.meth() end }
-          expect { surrogate.should substitute_for klass }.to \
+          expect { klass.should substitute_for surrogate }.to \
             raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate is missing class methods: [:meth]")
         end
 
         specify 'when combined' 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 \
+          expect { klass.should substitute_for surrogate }.to \
             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"\
@@ -109,7 +125,7 @@ describe 'substitute_for' do
         end
 
         specify "when negated (idk why you'd ever want this, though)" do
-          expect { surrogate.should_not substitute_for Class.new }.to \
+          expect { Class.new.should_not substitute_for surrogate }.to \
             raise_error(RSpec::Expectations::ExpectationNotMetError, "Should not have been substitute, but was")
         end
       end
@@ -121,29 +137,32 @@ describe 'substitute_for' do
   context 'subset substitutability -- specified with subset: true option' do
     context "returns true if api methods and inherited methods match are all implemented by other class. Examples:" do
       example 'true when exact match' do
-        Surrogate.endow(Class.new).should substitute_for Class.new, subset: true
+        Class.new.should substitute_for Surrogate.endow(Class.new), subset: true
       end
 
       example 'true when other has additional instance methods and class methods' do
         klass = Class.new { def self.class_meth()end; def instance_meth()end }
-        Surrogate.endow(Class.new).should substitute_for klass, subset: true
+        klass.should substitute_for Surrogate.endow(Class.new), subset: true
       end
 
       example 'false when other is missing instance methods' do
-        klass = Class.new { def self.extra_method()end; def extra_method()end }
-        expect { Surrogate.endow(Class.new).define(:meth).should substitute_for klass, subset:true }.to \
+        klass     = Class.new { def self.extra_method()end; def extra_method()end }
+        surrogate = Surrogate.endow(Class.new).define(:meth)
+        expect { klass.should substitute_for surrogate, subset:true }.to \
           raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra instance methods: [:meth]")
       end
 
       example 'false when other is missing class methods' do
-        klass = Class.new { def self.extra_method()end; def extra_method()end }
-        expect { Surrogate.endow(Class.new) { define :meth }.should substitute_for klass, subset:true }.to \
+        klass     = Class.new { def self.extra_method()end; def extra_method()end }
+        surrogate = Surrogate.endow(Class.new) { define :meth }
+        expect { klass.should substitute_for surrogate, subset:true }.to \
           raise_error(RSpec::Expectations::ExpectationNotMetError, "Was not substitutable because surrogate has extra class methods: [:meth]")
       end
 
       example 'false when other is missing instance and class methods' 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 \
+        surrogate = Surrogate.endow(Class.new) { define :class_meth }.define(:instance_meth)
+        expect { klass.should substitute_for surrogate, subset: true }.to \
           raise_error(RSpec::Expectations::ExpectationNotMetError,
                       "Was not substitutable because surrogate has extra instance methods: [:instance_meth]\nhas extra class methods: [:class_meth]")
       end
@@ -156,82 +175,165 @@ describe 'substitute_for' 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
+      klass.should_not substitute_for surrogate
+      klass.should substitute_for surrogate, 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
+      klass.should substitute_for surrogate, 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
+      klass.should substitute_for surrogate, 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
+      Array.should substitute_for surrogate, 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
+        klass.should substitute_for surrogate, 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.should_not substitute_for surrogate, 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
+        klass.should_not substitute_for surrogate, 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.should_not substitute_for surrogate, 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
+        klass.should_not substitute_for surrogate
       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.should_not substitute_for surrogate
 
         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
+        klass.should_not substitute_for surrogate, 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.should_not substitute_for surrogate, 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.should_not substitute_for surrogate, 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.should_not substitute_for surrogate, 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
+        klass.should_not substitute_for surrogate, types: true
+      end
+    end
+  end
+
+
+  context 'name substitutability -- specified with names: true/false option (DEFAULTS TO FALSE)' do
+    it 'is turned off by default' do
+      # instance
+      klass = Class.new { def instance_meth(a) end }
+      surrogate = Surrogate.endow(Class.new).define(:instance_meth) {|b|}
+      klass.should substitute_for surrogate
+      klass.should_not substitute_for surrogate, names: true
+
+      # class
+      klass = Class.new { def self.class_meth(a) end }
+      surrogate = Surrogate.endow(Class.new) { define(:class_meth) {|b|} }
+      klass.should substitute_for surrogate
+      klass.should_not substitute_for surrogate, names: true
+    end
+
+    it 'disregards when argument types differ' do
+      # instance
+      klass = Class.new { def instance_meth(a=1) end }
+      surrogate = Surrogate.endow(Class.new).define(:instance_meth) {|a|}
+      klass.should substitute_for surrogate, types: false, names: true
+
+      # class
+      klass = Class.new { def self.class_meth(a=1) end }
+      surrogate = Surrogate.endow(Class.new) { define(:class_meth) {|a|} }
+      klass.should substitute_for surrogate, types: false, names: true
+    end
+
+    it 'disregards when surrogate has no body for an api method' do
+      # instance
+      klass = Class.new { def instance_meth(a) end }
+      surrogate = Surrogate.endow(Class.new).define(:instance_meth)
+      klass.should substitute_for surrogate, names: true
+
+      # class
+      klass = Class.new { def self.class_meth(a) end }
+      surrogate = Surrogate.endow(Class.new) { define :class_meth }
+      klass.should substitute_for surrogate, names: 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| }
+      Array.should substitute_for surrogate, subset: true, names: true
+    end
+
+    context 'returns true if argument names match exactly. Examples:' do
+      specify 'true when exact match' do
+        klass = Class.new do
+          def self.class_meth(a) end
+          def instance_meth(b) end
+        end
+        surrogate = Surrogate.endow(Class.new) { define(:class_meth) {|a|} }.define(:instance_meth) {|b|}
+        klass.should substitute_for surrogate, names: true
+      end
+
+      specify 'false when different number of args' do
+        # instance
+        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| }
+        klass.should_not substitute_for surrogate, names: true
+
+        # class
+        klass = Class.new { def self.class_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new) { define(:class_meth) { |a, b=1, *c, d| } }
+        klass.should_not substitute_for surrogate, names: true
+      end
+
+      specify 'false when different names' do
+        # instance
+        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, &not_e| }
+        klass.should_not substitute_for surrogate, names: true
+
+        # class
+        klass = Class.new { def instance_meth(a, b=1, *c, d, &e) end }
+        surrogate = Surrogate.endow(Class.new) { define(:class_meth) { |a, b=1, *c, d, &not_e| } }
+        klass.should_not substitute_for surrogate, names: true
       end
     end
   end

data/spec/unit/api_comparer_spec.rb

@@ -10,7 +10,7 @@ describe Surrogate::ApiComparer do
   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 = described_class.new(Class.new, surrogate)
       comparer.compare[:instance][:types][:to_s][:surrogate].should ==
         [:req, :req, :req, :opt, :opt, :rest, :req, :block]
     end
@@ -40,7 +40,7 @@ describe Surrogate::ApiComparer do
       end
     end
 
-    let(:comparer) { described_class.new surrogate, Class.new }
+    let(:comparer) { described_class.new Class.new, surrogate }
 
     it "knows the surrogate's instance level api methods" do
       comparer.surrogate_methods[:instance][:api].should == Set[:api_instance_meth, :api_instance_meth_with_signature]
@@ -86,7 +86,7 @@ describe Surrogate::ApiComparer do
       Class.new(parent) { def self.class_meth()end; def instance_meth()end }
     end
 
-    let(:comparer) { described_class.new surrogate, actual }
+    let(:comparer) { described_class.new actual, surrogate }
 
     it "knows the object's inherited instance methods" do
       set_assertion comparer.actual_methods[:instance][:inherited],
@@ -131,7 +131,7 @@ describe Surrogate::ApiComparer do
       end
     end
 
-    let(:comparer) { described_class.new surrogate, actual }
+    let(:comparer) { described_class.new actual, surrogate }
 
     it 'tells me about instance methods on actual that are not on surrogate' do
       comparer.compare[:instance][:not_on_surrogate].should == Set[:instance_not_on_surrogate, :inherited_instance_not_on_surrogate, :instance_meth_on_both]
@@ -175,7 +175,7 @@ describe Surrogate::ApiComparer do
           def instance_meth3(e3, f3=1, *c3, &d3)end
         end
 
-        comparer = described_class.new surrogate, klass
+        comparer = described_class.new klass, surrogate
         comparer.compare[:instance][:types].should  == {}
         comparer.compare[:class][:types].should == {}
       end
@@ -192,7 +192,7 @@ describe Surrogate::ApiComparer do
           define(:instance_meth2) { |a, b, c, d| }
         end
 
-        described_class.new(surrogate, klass).compare
+        described_class.new(klass, surrogate).compare
         comparer.compare[:class][:types].should == {}
         comparer.compare[:instance][:types].should == {}
       end
@@ -200,7 +200,7 @@ describe Surrogate::ApiComparer do
       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
+        described_class.new(klass, surrogate).compare
         comparer.compare[:class][:types].should == {}
         comparer.compare[:instance][:types].should == {}
       end
@@ -217,7 +217,7 @@ describe Surrogate::ApiComparer do
           end
         end
 
-        comparer = described_class.new surrogate, klass
+        comparer = described_class.new klass, surrogate
         comparer.compare[:class][:types].should == {
           class_meth1: { actual:    [:req, :opt, :rest, :block],
                          surrogate: [      :opt, :rest, :block],
@@ -239,7 +239,7 @@ describe Surrogate::ApiComparer do
           define(:instance_meth2) { |a, *c, &d| }
         end
 
-        comparer = described_class.new surrogate, klass
+        comparer = described_class.new klass, surrogate
         comparer.compare[:instance][:types].should == {
           instance_meth1: { actual:    [:req, :opt, :rest, :block],
                             surrogate: [      :opt, :rest, :block],

data/spec/unit/argument_errorizer_spec.rb

@@ -6,6 +6,7 @@ describe Surrogate::ArgumentErrorizer do
   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
+      expect { described_class.new(meth_name, ->(a){}).match! }.to raise_error ArgumentError
     end
 
     it 'does not raise any errors if the arguments do match' do
@@ -47,4 +48,12 @@ describe Surrogate::ArgumentErrorizer do
     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
+
+  it 'raises an ArgumentError if initialized with a non lambda/method' do
+    def self.some_method() end
+    described_class.new 'some_name', method(:some_method)
+    described_class.new 'some_name', lambda {}
+    expect { described_class.new 'some_name', Proc.new {} }.to raise_error ArgumentError, 'Expected a lambda or method, got a Proc'
+    expect { described_class.new 'some_name', 'abc' }.to raise_error ArgumentError, 'Expected a lambda or method, got a String'
+  end
 end

data/todo

@@ -1,13 +1,11 @@
 Urgent (things I want to do immediately, formatted as the git commits I will use)
 ---------------------------------------------------------------------------------
 
+* refactor the stupid interface code, api comparer is fucking gross
 * be smart enough to handle method missing
-* tests around the error messages of types
-* Substitutability can check argument names
+* tests around the error messages of types and names
 * substitute_for should not depend on rspec-expectations
 * Error messages on blocks are actually useful
-* error message
-    "Doesn't know initialize, only knows " <-- fix that shit
 
 TODO (next up after urgent, these will happen whenever I get around to it)
 --------------------------------------------------------------------------
@@ -18,7 +16,6 @@ TODO (next up after urgent, these will happen whenever I get around to it)
 * 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)
 * config: rspec_mocks loaded, whether unprepared blocks should raise or just return nil
 * extract surrogate/rspec into its own gem
-* make substitutability matcher go either way
 * make substitutability matcher not care whether either are surrogates
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: surrogate
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-13 00:00:00.000000000 Z
+date: 2012-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70147459182300 !ruby/object:Gem::Requirement
+  requirement: &70208657501360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70147459182300
+  version_requirements: *70208657501360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70147459181540 !ruby/object:Gem::Requirement
+  requirement: &70208657500800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.4'
   type: :development
   prerelease: false
-  version_requirements: *70147459181540
+  version_requirements: *70208657500800
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields
-  requirement: &70147459180560 !ruby/object:Gem::Requirement
+  requirement: &70208657500220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70147459180560
+  version_requirements: *70208657500220
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-rspec
-  requirement: &70147459179620 !ruby/object:Gem::Requirement
+  requirement: &70208657499660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.0.3
   type: :development
   prerelease: false
-  version_requirements: *70147459179620
+  version_requirements: *70208657499660
 - !ruby/object:Gem::Dependency
   name: mountain_berry_fields-magic_comments
-  requirement: &70147459178820 !ruby/object:Gem::Requirement
+  requirement: &70208657499120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: 1.0.1
   type: :development
   prerelease: false
-  version_requirements: *70147459178820
+  version_requirements: *70208657499120
 description: Framework to aid in handrolling mock/spy objects.
 email:
 - josh.cheek@gmail.com