surrogate 0.5.5 → 0.6.0

data/gemfiles/rspec_mocks_2.11

@@ -1,5 +1,5 @@
 # set this with
-# export BUNDLE_GEMFILE=gemfiles/rspec_mocks_2.10
+# export BUNDLE_GEMFILE=gemfiles/rspec_mocks_2.11
 
 source "http://rubygems.org"
 

data/lib/surrogate.rb

@@ -1,7 +1,7 @@
 require 'surrogate/version'
 require 'surrogate/hatchling'
 require 'surrogate/hatchery'
-require 'surrogate/options'
+require 'surrogate/method_definition'
 require 'surrogate/values'
 require 'surrogate/endower'
 require 'surrogate/api_comparer'

data/lib/surrogate/api_comparer.rb

@@ -1,4 +1,6 @@
 require 'set'
+require 'surrogate/surrogate_class_reflector'
+require 'surrogate/porc_reflector'
 
 class Surrogate
 
@@ -11,11 +13,11 @@ class Surrogate
     end
 
     def surrogate_methods
-      @surrogate_methods ||= SurrogateMethods.new(surrogate).methods
+      @surrogate_methods ||= SurrogateClassReflector.new(surrogate).methods
     end
 
     def actual_methods
-      @actual_methods ||= ActualMethods.new(actual).methods
+      @actual_methods ||= PorcReflector.new(actual).methods
     end
 
     def compare
@@ -23,10 +25,12 @@ class Surrogate
         instance: {
           not_on_surrogate: instance_not_on_surrogate,
           not_on_actual:    instance_not_on_actual,
+          types:            instance_types,
         },
         class: {
           not_on_surrogate: class_not_on_surrogate,
           not_on_actual:    class_not_on_actual,
+          types:            class_types,
         },
       }
     end
@@ -49,78 +53,72 @@ class Surrogate
       surrogate_methods[:class][:api] - actual_methods[:class][:inherited] - actual_methods[:class][:other]
     end
 
-    # methods from the actual class (as opposed to "these are actually methods"
-    class ActualMethods < Struct.new(:actual)
-      def methods
-        { instance: {
-            inherited: instance_inherited_methods,
-            other:     instance_other_methods,
-          },
-          class: {
-            inherited: class_inherited_methods,
-            other:     class_other_methods,
-          },
-        }
-      end
-
-      def instance_inherited_methods
-        Set.new actual.instance_methods - actual.instance_methods(false)
+    # 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
+        hash[name] = { surrogate: surrogate_type, actual: actual_type }
       end
+    end
 
-      def instance_other_methods
-        Set.new(actual.instance_methods) - instance_inherited_methods
+    # 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
+        hash[name] = { surrogate: surrogate_type, actual: actual_type }
       end
+    end
 
-      def class_inherited_methods
-        Set.new actual.singleton_class.instance_methods - actual.singleton_class.instance_methods(false)
-      end
+    private
 
-      def class_other_methods
-        Set.new(actual.singleton_class.instance_methods) - class_inherited_methods
-      end
+    def class_types_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 type_for(surrogate_method), type_for(actual_method)
     end
 
+    def instance_types_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 type_for(surrogate_method), type_for(actual_method)
+    end
 
-    class SurrogateMethods < Struct.new(:surrogate)
-      def methods
-        { instance: {
-            api:       instance_api_methods,
-            inherited: instance_inherited_methods,
-            other:     instance_other_methods,
-          },
-          class: {
-            api:       class_api_methods,
-            inherited: class_inherited_methods,
-            other:     class_other_methods,
-          },
-        }
-      end
-
-      def instance_api_methods
-        Set.new surrogate.api_method_names
-      end
+    def type_for(method)
+      method.parameters.map(&:first)
+    end
 
-      def instance_inherited_methods
-        Set.new surrogate.instance_methods - surrogate.instance_methods(false)
-      end
+    def to_lambda(proc)
+      obj = Object.new
+      obj.singleton_class.send :define_method, :abc123, &proc
+      obj.method :abc123
+    end
 
-      def instance_other_methods
-        Set.new(surrogate.instance_methods false) - instance_api_methods
-      end
+    def instance_api_method_for(name)
+      class_hatchery.api_method_for name
+    end
 
-      def class_api_methods
-        Set.new surrogate.singleton_class.api_method_names
-      end
+    def class_api_method_for(name)
+      singleton_class_hatchery.api_method_for name
+    end
 
-      # should have new and clone (don't screw up substitutability because of how we implement these)
-      def class_inherited_methods
-        Set.new surrogate.singleton_class.instance_methods - surrogate.singleton_class.instance_methods(false)
-      end
+    def class_hatchery
+      @class_hatchery ||= surrogate.instance_variable_get :@hatchery
+    end
 
-      # should not have new
-      def class_other_methods
-        Set.new(surrogate.singleton_class.instance_methods false) - class_api_methods - class_inherited_methods
-      end
+    def singleton_class_hatchery
+      @singleton_class_hatchery ||= surrogate.singleton_class.instance_variable_get :@hatchery
     end
   end
 end

data/lib/surrogate/argument_errorizer.rb

@@ -0,0 +1,43 @@
+class Surrogate
+
+  # Give it a name and lambda, it will raise an argument error if they don't match, without actually invoking the method.
+  # Its error message includes the signature of the message (maybe should also show what was passed in?)
+  class ArgumentErrorizer
+    attr_accessor :name, :empty_lambda
+
+    def initialize(name, lambda_or_method)
+      self.name, self.empty_lambda = name.to_s, lambda_with_same_params_as(lambda_or_method)
+    end
+
+    def match!(*args)
+      empty_lambda.call *args
+    rescue ArgumentError => e
+      raise ArgumentError, e.message + " in #{name}(#{lambda_signature empty_lambda})"
+    end
+
+    private
+
+    def lambda_with_same_params_as(lambda_or_method)
+      eval "->(" << lambda_signature(lambda_or_method) << ") {}"
+    end
+
+    def lambda_signature(lambda_or_method)
+      lambda_or_method.parameters.map { |type, name| param_for type, name }.compact.join(', ')
+    end
+
+    def param_for(type, name)
+      case type
+      when :req
+        name
+      when :opt
+        "#{name}='?'"
+      when :rest
+        "*#{name}"
+      when :block
+        "&#{name}"
+      else
+        raise "forgot to account for #{type.inspect}"
+      end
+    end
+  end
+end

data/lib/surrogate/endower.rb

@@ -34,8 +34,7 @@ class Surrogate
       klass.extend ClassMethods
       add_hatchery_to                        klass
       enable_defining_methods                klass
-      record_initialization_for_instances_of klass
-      remember_invocations_for_instances_of  klass
+      klass.send :include, InstanceMethods
       invoke_hooks                           klass
     end
 
@@ -44,7 +43,6 @@ class Surrogate
       enable_defining_methods singleton
       singleton.module_eval &block if block
       klass.instance_variable_set :@hatchling, Hatchling.new(klass, hatchery)
-      remember_invocations_for_instances_of  singleton
       invoke_hooks                           singleton
       klass
     end
@@ -53,37 +51,10 @@ class Surrogate
       self.class.hooks.each { |hook| hook.call klass }
     end
 
-    # yeesh :( pretty sure there isn't a better way to do this
-    def record_initialization_for_instances_of(klass)
-      def klass.method_added(meth)
-        return if meth != :initialize || @hijacking_initialize
-        @hijacking_initialize = true
-        current_initialize = instance_method :initialize
-
-        # `define' records the args while maintaining the old behaviour
-        # we have to do it stupidly like this because there is no to_proc on an unbound method
-        define :initialize do |*args, &block|
-          current_initialize.bind(self).call(*args, &block)
-        end
-      ensure
-        @hijacking_initialize = false
-      end
-      initialize = klass.instance_method :initialize
-      klass.__send__ :define_method, :initialize do |*args, &block|
-        initialize.bind(self).call(*args, &block)
-      end
-    end
-
     def singleton
       klass.singleton_class
     end
 
-    def remember_invocations_for_instances_of(klass)
-      klass.__send__ :define_method, :invocations do |method_name|
-        @hatchling.invocations method_name
-      end
-    end
-
     def add_hatchery_to(klass)
       klass.instance_variable_set :@hatchery, Surrogate::Hatchery.new(klass)
     end
@@ -92,10 +63,6 @@ class Surrogate
       def klass.define(method_name, options={}, &block)
         @hatchery.define method_name, options, &block
       end
-
-      def klass.api_method_names
-        @hatchery.api_method_names
-      end
     end
   end
 
@@ -106,8 +73,9 @@ class Surrogate
     # Should this be dup? (dup seems to copy singleton methods) and may be able to use #initialize_copy to reset ivars
     # Can we just remove this feature an instead provide a reset feature which could be hooked into in before/after blocks (e.g. https://github.com/rspec/rspec-core/blob/622505d616d950ed53d12c6e82dbb953ba6241b4/lib/rspec/core/mocking/with_rspec.rb)
     def clone
-      hatchling, hatchery = @hatchling, @hatchery
+      hatchling, hatchery, parent_name = @hatchling, @hatchery, name
       Class.new self do
+        extend Module.new { define_method(:name) { parent_name && parent_name + '.clone' } } # inherit the name -- use module so that ApiComparison comes out correct (real classes inherit their name method)
         Surrogate.endow self do
           hatchling.api_methods.each { |name, options| define name, options.to_hash, &options.default_proc }
         end
@@ -116,12 +84,11 @@ class Surrogate
     end
 
     # Custom new, because user can define initialize, and we need to record it
-    # Can we move this into the redefinition of initialize and have it explicitly record itself?
     def new(*args)
       instance = allocate
       self.last_instance = instance
       instance.instance_variable_set :@hatchling, Hatchling.new(instance, @hatchery)
-      instance.send :initialize, *args
+      instance.__send__ :initialize, *args
       instance
     end
 
@@ -132,5 +99,42 @@ class Surrogate
     def last_instance=(instance)
       Thread.current["surrogate_last_instance_#{self.object_id}"] = instance
     end
+
+
+    def inspect
+      return name if name
+      methods = SurrogateClassReflector.new(self).methods
+      method_inspections = []
+
+      # add class methods
+      if methods[:class][:api].any?
+        meth_names = methods[:class][:api].to_a.sort.take(4)
+        meth_names[-1] = '...' if meth_names.size == 4
+        method_inspections << "Class: #{meth_names.join ' '}"
+      end
+
+      # add instance methods
+      if methods[:instance][:api].any?
+        meth_names = methods[:instance][:api].to_a.sort.take(4)
+        meth_names[-1] = '...' if meth_names.size == 4
+        method_inspections << "Instance: #{meth_names.join ' '}"
+      end
+
+      # when no class or instance methods
+      method_inspections << "no api" if method_inspections.empty?
+
+      "AnonymousSurrogate(#{method_inspections.join ', '})"
+    end
+  end
+
+  # Use module so the method is inherited. This allows proper matching (e.g. other object will inherit inspect from Object)
+  module InstanceMethods
+    def inspect
+      methods = SurrogateClassReflector.new(self.class).methods[:instance][:api].sort.take(4)
+      methods[-1] = '...' if methods.size == 4
+      methods << 'no api' if methods.empty?
+      class_name = self.class.name || 'AnonymousSurrogate'
+      "#<#{class_name}: #{methods.join ' '}>"
+    end
   end
 end

data/lib/surrogate/hatchery.rb

@@ -15,7 +15,7 @@ class Surrogate
       add_api_method_for method_name
       add_verb_helpers_for method_name
       add_noun_helpers_for method_name
-      api_methods[method_name] = Options.new options, block
+      api_methods[method_name] = MethodDefinition.new method_name, options, block
       klass
     end
 
@@ -27,6 +27,11 @@ class Surrogate
       api_methods.keys - [:initialize]
     end
 
+    def api_method_for(name)
+      options = api_methods[name]
+      options && options.default_proc
+    end
+
     private
 
     def klass_can_define_api_methods

data/lib/surrogate/hatchling.rb

@@ -20,6 +20,7 @@ class Surrogate
       invocation = Invocation.new(args, &block)
       invoked_methods[method_name] << invocation
       return get_default method_name, invocation, &block unless has_ivar? method_name
+      interfaces_must_match! method_name, args
       Value.factory(get_ivar method_name).value(method_name)
     end
 
@@ -40,6 +41,10 @@ class Surrogate
       end
     end
 
+    def interfaces_must_match!(method_name, args)
+      api_methods[method_name].must_match! args
+    end
+
     def get_default(method_name, invocation)
       api_methods[method_name].default instance, invocation do
         raise UnpreparedMethodError, "#{method_name} has been invoked without being told how to behave"

data/lib/surrogate/method_definition.rb

@@ -0,0 +1,55 @@
+require 'surrogate/argument_errorizer'
+
+class Surrogate
+
+  # A surrogate's `define` keyword results in one of these
+  class MethodDefinition
+    attr_accessor :name, :options, :default_proc
+
+    def initialize(name, options, default_proc)
+      self.name, self.options, self.default_proc = name, options, default_proc
+    end
+
+    def has?(name)
+      options.has_key? name
+    end
+
+    def [](key)
+      options[key]
+    end
+
+    def to_hash
+      options
+    end
+
+    def must_match!(args)
+      default_proc && errorizer.match!(*args)
+    end
+
+    def default(instance, invocation, &no_default)
+      if options.has_key? :default
+        options[:default]
+      elsif default_proc
+        default_proc_as_method_on(instance).call(*invocation.args, &invocation.block)
+      else
+        no_default.call
+      end
+    end
+
+    private
+
+    def errorizer
+      @errorizer ||= ArgumentErrorizer.new name, default_proc
+    end
+
+    def default_proc_as_method_on(instance)
+      unique_name = "surrogate_temp_method_#{Time.now.to_i}_#{rand 10000000}"
+      klass = instance.singleton_class
+      klass.__send__ :define_method, unique_name, &default_proc
+      as_method = klass.instance_method unique_name
+      klass.__send__ :remove_method, unique_name
+      as_method.bind instance
+    end
+  end
+end
+