surrogate 0.5.5 → 0.6.0

data/lib/surrogate/porc_reflector.rb

@@ -0,0 +1,43 @@
+require 'set'
+class Surrogate
+  # reflects on the Plain Old Ruby Class to give info about methods that are useful for the comparer
+  class PorcReflector < Struct.new(:actual)
+    def methods
+      { instance: {
+          inherited:      instance_inherited_methods,
+          other:          instance_other_methods,
+          without_bodies: instance_without_bodies,
+        },
+        class: {
+          inherited:      class_inherited_methods,
+          other:          class_other_methods,
+          without_bodies: class_without_bodies,
+        },
+      }
+    end
+
+    def instance_inherited_methods
+      Set.new actual.instance_methods - actual.instance_methods(false)
+    end
+
+    def instance_other_methods
+      Set.new(actual.instance_methods) - instance_inherited_methods
+    end
+
+    def class_inherited_methods
+      Set.new actual.singleton_class.instance_methods - actual.singleton_class.instance_methods(false)
+    end
+
+    def class_other_methods
+      Set.new(actual.singleton_class.instance_methods) - class_inherited_methods
+    end
+
+    def class_without_bodies
+      Set.new actual.methods.select { |name| actual.method(name).parameters.any? { |param| param.size == 1 } }
+    end
+
+    def instance_without_bodies
+      Set.new actual.instance_methods.select { |name| actual.instance_method(name).parameters.any? { |param| param.size == 1 } }
+    end
+  end
+end

data/lib/surrogate/rspec/invocation_matcher.rb

@@ -1,6 +1,7 @@
 require 'surrogate/rspec/abstract_failure_message'
 require 'surrogate/rspec/times_predicate'
 require 'surrogate/rspec/with_filter'
+require 'surrogate/surrogate_instance_reflector'
 
 class Surrogate
   module RSpec
@@ -23,7 +24,7 @@ class Surrogate
       end
 
       def invocations
-        surrogate.invocations(method_name)
+        SurrogateInstanceReflector.new(surrogate).invocations(method_name)
       end
 
       def failure_message_for_should

data/lib/surrogate/rspec/substitute_for.rb

@@ -1,16 +1,24 @@
 class Surrogate
   ::RSpec::Matchers.define :substitute_for do |original_class, options={}|
 
-    comparison = nil
+    comparison  = nil
     subset_only = options[:subset]
+    types       = options.fetch :types, true
+
+    def comparing_fields(comparison, subset_only, types)
+      fields = {}
+      fields[:instance_not_on_actual   ] = comparison[:instance][:not_on_actual]
+      fields[:class_not_on_actual      ] = comparison[:class   ][:not_on_actual]
+      fields[:instance_not_on_surrogate] = comparison[:instance][:not_on_surrogate] unless subset_only
+      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
+    end
 
     match do |mocked_class|
       comparison = ApiComparer.new(mocked_class, original_class).compare
-      if subset_only
-        (comparison[:instance][:not_on_actual] + comparison[:class][:not_on_actual]).empty?
-      else
-        (comparison[:instance].values + comparison[:class].values).inject(:+).empty?
-      end
+      comparing_fields(comparison, subset_only, types).values.inject(:+).empty?
     end
 
     failure_message_for_should do
@@ -18,13 +26,21 @@ class Surrogate
       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           ]
+
 
       differences = []
       differences << "has extra instance methods: #{extra_instance_methods.inspect}" if extra_instance_methods.any?
       differences << "has extra class methods: #{extra_class_methods.inspect}"       if extra_class_methods.any?
       differences << "is missing instance methods: #{missing_instance_methods}"      if !subset_only && missing_instance_methods.any?
       differences << "is missing class methods: #{missing_class_methods}"            if !subset_only && missing_class_methods.any?
-      "Was not substitutable because surrogate " << differences.join(', ')
+
+      if types # this conditional is not tested, nor are these error messages
+        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
+      "Was not substitutable because surrogate " << differences.join("\n")
     end
 
     failure_message_for_should_not do

data/lib/surrogate/rspec/with_filter.rb

@@ -94,7 +94,6 @@ class Surrogate
 
 
 
-      # rename args to invocation
       attr_accessor :expected_invocation, :block, :pass, :filter_name
 
       def initialize(args=[], filter_name=:default_filter, &block)

data/lib/surrogate/surrogate_class_reflector.rb

@@ -0,0 +1,65 @@
+require 'set'
+class Surrogate
+
+  # Reflects on the surrogate class to give info about methods that are useful for the comparer
+  #
+  # It might make sense to not treat instance and class differently, but instead let whoever wants to use this
+  # instantiate it with both the class and the singleton class.
+  class SurrogateClassReflector < Struct.new(:surrogate_class)
+    def methods
+      { instance: {
+          api:            instance_api_methods,
+          inherited:      instance_inherited_methods,
+          other:          instance_other_methods,
+          without_bodies: instance_without_bodies,
+        },
+        class: {
+          api:            class_api_methods,
+          inherited:      class_inherited_methods,
+          other:          class_other_methods,
+          without_bodies: class_without_bodies,
+        },
+      }
+    end
+
+    def instance_api_methods
+      Set.new class_hatchery.api_method_names
+    end
+
+    def instance_inherited_methods
+      Set.new surrogate_class.instance_methods - surrogate_class.instance_methods(false)
+    end
+
+    def instance_other_methods
+      Set.new(surrogate_class.instance_methods false) - instance_api_methods
+    end
+
+    def instance_without_bodies
+      Set.new class_hatchery.api_method_names.reject { |name| class_hatchery.api_method_for name }
+    end
+
+    def class_api_methods
+      Set.new singleton_class_hatchery.api_method_names
+    end
+
+    def class_inherited_methods
+      Set.new surrogate_class.singleton_class.instance_methods - surrogate_class.singleton_class.instance_methods(false)
+    end
+
+    def class_other_methods
+      Set.new(surrogate_class.singleton_class.instance_methods false) - class_api_methods - class_inherited_methods
+    end
+
+    def class_without_bodies
+      Set.new singleton_class_hatchery.api_method_names.reject { |name| singleton_class_hatchery.api_method_for name }
+    end
+
+    def class_hatchery
+      @class_hatchery ||= surrogate_class.instance_variable_get :@hatchery
+    end
+
+    def singleton_class_hatchery
+      @singleton_class_hatchery ||= surrogate_class.singleton_class.instance_variable_get :@hatchery
+    end
+  end
+end

data/lib/surrogate/surrogate_instance_reflector.rb

@@ -0,0 +1,15 @@
+class Surrogate
+
+  # Utilities for reflecting on surrogate instances
+  #
+  # Primarily it exists to avoid having to pollute the surrogate with reflection methods
+  class SurrogateInstanceReflector < Struct.new(:surrogate)
+    def invocations(method_name)
+      hatchling.invocations(method_name)
+    end
+
+    def hatchling
+      @hatchling ||= surrogate.instance_variable_get :@hatchling
+    end
+  end
+end

data/lib/surrogate/version.rb

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

data/spec/acceptance_spec.rb

@@ -116,7 +116,7 @@ describe Surrogate do
 
     # real user must have all of mock user's methods to be substitutable
     substitutable_real_user_class = Class.new do
-      def self.find() end
+      def self.find(id) end
       def initialize(id) end
       def id() end
       def name() end

data/spec/defining_api_methods_spec.rb

@@ -1,13 +1,25 @@
 require 'spec_helper'
 
 describe 'define' do
+  def class_method_names(surrogate)
+    Surrogate::SurrogateClassReflector.new(surrogate).class_api_methods
+  end
+
+  def instance_method_names(surrogate)
+    Surrogate::SurrogateClassReflector.new(surrogate).instance_api_methods
+  end
+
+  def invocations(surrogate, method_name)
+    Surrogate::SurrogateInstanceReflector.new(surrogate).invocations(method_name)
+  end
+
   let(:mocked_class) { Surrogate.endow Class.new }
   let(:instance)     { mocked_class.new }
 
   describe 'in the block' do
     it 'is an api method for the class' do
       pristine_klass = Class.new { Surrogate.endow(self) { define :find } }
-      pristine_klass.singleton_class.api_method_names.should == [:find]
+      class_method_names(pristine_klass).should == Set[:find]
     end
   end
 
@@ -15,18 +27,11 @@ describe 'define' do
   describe 'out of the block' do
     it 'is an api method for the instance' do
       mocked_class.define :book
-      mocked_class.api_method_names.should == [:book]
+      instance_method_names(mocked_class).should == Set[:book]
     end
   end
 
   describe 'definition default block invocation' do
-    xit "something about raising an error if arity is wrong" do
-      mocked_class.define(:a) { |arg| 1 }
-      mocked_class.new.a.should == 1
-      mocked_class.new.a(2).should == 1
-      mocked_class.new.a(3).should == 1
-    end
-
     it "is passed the arguments" do
       arg = nil
       mocked_class.define(:meth) { |inner_arg| arg = inner_arg }.new.meth(1212)
@@ -45,7 +50,6 @@ describe 'define' do
   end
 
   describe 'declaring the behaviour' do
-
     describe 'for verbs' do
       before { mocked_class.define :wink }
 
@@ -144,11 +148,11 @@ describe 'define' do
 
 
   context 'the api method' do
-    it 'takes any number of arguments' do
-      mocked_class.define(:meth) { 1 }
-      mocked_class.new.meth.should == 1
+    it 'has the same arity as the method' do
+      mocked_class.define(:meth) { |a| a }
       mocked_class.new.meth(1).should == 1
-      mocked_class.new.meth(1, 2).should == 1
+      expect { mocked_class.new.meth }.to raise_error ArgumentError, /0 for 1/
+      expect { mocked_class.new.meth 1, 2 }.to raise_error ArgumentError, /2 for 1/
     end
 
     it 'raises an UnpreparedMethodError when it has no default block' do
@@ -177,58 +181,26 @@ describe 'define' do
       mocked.meth.should == 123
     end
 
-    describe 'initialization' do
-      specify 'api methods can be an initialize method' do
-        mocked_class.define(:initialize) { @abc = 123 }
-        mocked_class.new.instance_variable_get(:@abc).should == 123
-      end
-
-      specify 'initialize exsits even if error is raised' do
-        mocked_class.define(:initialize) { raise "simulate runtime error" }
-        expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
-        expect { mocked_class.new }.to raise_error(RuntimeError, /simulate/)
-      end
-
-      specify 'receives args' do
-        mocked_class.define(:initialize) { |num1, num2| @num = num1 + num2 }
-        mocked_class.new(25, 75).instance_variable_get(:@num).should == 100
-      end
-
-      specify 'even works with inheritance' do
-        superclass = Class.new
-        superclass.send(:define_method, :initialize) { @a = 1 }
-        subclass = Surrogate.endow Class.new superclass
-        subclass.define :abc
-        subclass.new.instance_variable_get(:@a).should == 1
-      end
+    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\)/
+    end
 
-      context 'when not an api method' do
-        it 'respects arity (this is probably 1.9.3 only)' do
-          expect { mocked_class.new 1 }.to raise_error ArgumentError, 'wrong number of arguments(1 for 0)'
-        end
+    it 'does not raise arity errors, when there is no default block and the value is overridden' do
+      mocked_class.define :meth
+      mocked = mocked_class.new
+      mocked.instance_variable_set :@meth, "abc"
+      mocked.meth 1, 2, 3
+    end
 
-        describe 'invocations are recorded anyway' do
-          specify 'even when initialize is defined after surrogate block' do
-            klass = Class.new do
-              Surrogate.endow self
-              def initialize(a) @a = a end
-            end
-            klass.new(1).should have_been_initialized_with 1
-            klass.new(1).instance_variable_get(:@a).should == 1
-          end
-
-          specify 'even when initialize is defined before surrogate block' do
-            klass = Class.new do
-              def initialize(a) @a = a end
-              Surrogate.endow self
-            end
-            klass.new(1).should have_been_initialized_with 1
-            klass.new(1).instance_variable_get(:@a).should == 1
-          end
-        end
-      end
+    it 'can make #initialize an api method' do
+      mocked_class.define(:initialize) { @abc = 123 }
+      mocked_class.new.instance_variable_get(:@abc).should == 123
     end
 
+
     describe 'it takes a block whos return value will be used as the default' do
       specify 'the block is instance evaled' do
         mocked_class.define(:meth) { self }
@@ -245,32 +217,32 @@ describe 'define' do
     end
 
     it 'remembers what it was invoked with' do
-      mocked_class.define(:meth) { nil }
+      mocked_class.define(:meth) { |*| nil }
       mock = mocked_class.new
       mock.meth 1
       mock.meth 1, 2
-      mock.invocations(:meth).should == [Surrogate::Invocation.new([1]), Surrogate::Invocation.new([1, 2])]
+      invocations(mock, :meth).should == [Surrogate::Invocation.new([1]), Surrogate::Invocation.new([1, 2])]
 
       val = 0
       mock.meth(1, 2) { val =  3 }
-      expect { mock.invocations(:meth).last.block.call }.to change { val }.from(0).to(3)
+      expect { invocations(mock, :meth).last.block.call }.to change { val }.from(0).to(3)
     end
 
     it 'raises an error if asked about invocations for api methods it does not know' do
       mocked_class.define :meth1
       mocked_class.define :meth2
       mock = mocked_class.new
-      expect { mock.invocations(:meth1) }.to_not raise_error
-      expect { mock.invocations(:meth3) }.to raise_error Surrogate::UnknownMethod, /doesn't know "meth3", only knows "initialize", "meth1", "meth2"/
+      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"/
     end
   end
 
 
   describe 'clone' do
-    it 'a repetition or further performance of the klass' do
+    example 'acceptance spec' do
       pristine_klass = Class.new do
         Surrogate.endow self do
-          define(:find) { 123 }
+          define(:find) { |n| 123 }
           define(:bind) { 'abc' }
         end
         define(:peat)   { true }
@@ -286,7 +258,7 @@ describe 'define' do
       klass2 = pristine_klass.clone
       klass2.will_find 456
       klass2.find(2).should == 456
-      klass1.find.should == 123
+      klass1.find(3).should == 123
 
       klass1.should have_been_told_to(:find).with(1)
       klass2.should have_been_told_to(:find).with(2)
@@ -301,15 +273,17 @@ describe 'define' do
       superclass = Surrogate.endow Class.new
       superclass.clone.new.should be_a_kind_of superclass
     end
-  end
 
-  describe '#api_method_names' do
-    it 'returns the names of the api methods as symbols' do
-      mocked_class = Class.new do
-        Surrogate.endow self
-        define :abc
+    describe '.name' do
+      it 'is nil for anonymous classes' do
+        Surrogate.endow(Class.new).clone.name.should be_nil
+      end
+
+      it "is the class's name suffixed with '.clone' for named classes" do
+        klass = Surrogate.endow(Class.new)
+        self.class.const_set 'Xyz', klass
+        klass.clone.name.should == self.class.name + '::Xyz.clone'
       end
-      mocked_class.api_method_names.should == [:abc]
     end
   end
 end

data/spec/other_shit_spec.rb

@@ -52,3 +52,134 @@ describe '.last_instance' do
     end
   end
 end
+
+
+describe 'inspect methods' do
+  context 'on the class' do
+    context 'when anonymous identifies itself as an anonymous surrogate and lists three each of class and instance methods, alphabetically' do
+      example 'no class methods' do
+        Surrogate.endow(Class.new).inspect.should == 'AnonymousSurrogate(no api)'
+      end
+
+      example 'one class method' do
+        klass = Surrogate.endow(Class.new) { define :cmeth }
+        klass.inspect.should == 'AnonymousSurrogate(Class: cmeth)'
+      end
+
+      example 'more than three class methods' do
+        Surrogate.endow(Class.new) do
+          define :cmethd
+          define :cmethc
+          define :cmetha
+          define :cmethb
+        end.inspect.should == 'AnonymousSurrogate(Class: cmetha cmethb cmethc ...)'
+      end
+
+      example 'one instance method' do
+        Surrogate.endow(Class.new).define(:imeth).inspect.should == 'AnonymousSurrogate(Instance: imeth)'
+      end
+
+      example 'more than three instance methods' do
+        klass = Surrogate.endow Class.new
+        klass.define :imethd
+        klass.define :imethc
+        klass.define :imetha
+        klass.define :imethb
+        klass.inspect.should == 'AnonymousSurrogate(Instance: imetha imethb imethc ...)'
+      end
+
+      example 'one of each' do
+        Surrogate.endow(Class.new) { define :cmeth }.define(:imeth).inspect.should == 'AnonymousSurrogate(Class: cmeth, Instance: imeth)'
+      end
+
+      example 'more than three of each' do
+        klass = Surrogate.endow Class.new do
+          define :cmethd
+          define :cmethc
+          define :cmetha
+          define :cmethb
+        end
+        klass.define :imethd
+        klass.define :imethc
+        klass.define :imetha
+        klass.define :imethb
+        klass.inspect.should == 'AnonymousSurrogate(Class: cmetha cmethb cmethc ..., Instance: imetha imethb imethc ...)'
+      end
+    end
+
+    context 'when the surrogate has a name (e.g. assigned to a constant)' do
+      it 'inspects to the name of the constant' do
+        klass = Surrogate.endow(Class.new)
+        self.class.const_set 'Abc', klass
+        klass.inspect.should == self.class.name << '::Abc'
+      end
+    end
+  end
+
+  context 'on a clone of the surrogate' do
+    context 'when the surrogate has a name (e.g. assigned to a constant)' do
+      it 'inspects to the name of the constant, cloned' do
+        klass = Surrogate.endow(Class.new)
+        self.class.const_set 'Abc', klass
+        klass.clone.inspect.should == self.class.name << '::Abc.clone'
+      end
+    end
+  end
+
+  # eventually these should maybe show unique state (expectations/invocations) but for now, this is better than what was there before
+  context 'on the instance' do
+    context 'when anonymous' do
+      it 'identifies itself as an anonymous surrogate and lists three of its methods, alphabetically' do
+        klass = Surrogate.endow Class.new
+        klass.new.inspect.should == '#<AnonymousSurrogate: no api>'
+        klass.define :imethb
+        klass.new.inspect.should == '#<AnonymousSurrogate: imethb>'
+        klass.define :imetha
+        klass.define :imethd
+        klass.new.inspect.should == '#<AnonymousSurrogate: imetha imethb imethd>'
+        klass.define :imethc
+        klass.new.inspect.should == '#<AnonymousSurrogate: imetha imethb imethc ...>'
+      end
+    end
+
+    context 'when a clone of an anonymous surrogate' do
+      it 'looks the same as any other anonymous surrogate' do
+        klass = Surrogate.endow Class.new
+        klass.new.inspect.should == '#<AnonymousSurrogate: no api>'
+      end
+    end
+
+    context 'when its class has a name (e.g. for a constant)' do
+      it 'identifies itself as an instance of the constant and lists three of its methods, alphabetically' do
+        klass = Surrogate.endow Class.new
+        self.class.const_set 'Abc', klass
+        klass.stub name: 'Abc'
+        klass.new.inspect.should == "#<Abc: no api>"
+        klass.define :imethb
+        klass.new.inspect.should == "#<Abc: imethb>"
+        klass.define :imetha
+        klass.define :imethd
+        klass.new.inspect.should == "#<Abc: imetha imethb imethd>"
+        klass.define :imethc
+        klass.new.inspect.should == "#<Abc: imetha imethb imethc ...>"
+      end
+    end
+  end
+
+  context 'on an instance of a surrogate clone' do
+    context 'when its class has a name (e.g. for a constant)' do
+      it 'identifies itself as an instance of the clone of the constant and lists three of its methods, alphabetically' do
+        klass = Surrogate.endow Class.new
+        self.class.const_set 'Abc', klass
+        klass.clone.new.inspect.should == "#<#{self.class}::Abc.clone: no api>"
+        klass.define :imethb
+        klass.clone.new.inspect.should == "#<#{self.class}::Abc.clone: imethb>"
+        klass.define :imetha
+        klass.define :imethd
+        klass.clone.new.inspect.should == "#<#{self.class}::Abc.clone: imetha imethb imethd>"
+        klass.define :imethc
+        klass.clone.new.inspect.should == "#<#{self.class}::Abc.clone: imetha imethb imethc ...>"
+      end
+    end
+  end
+end