surrogate 0.6.2 → 0.6.3

data/Changelog.md

@@ -1,3 +1,10 @@
+### 0.6.3
+
+* Allow mass initialization of instances with `MockClass.factory key: value`
+* The `.factory` method can be turned off with `Surrogate.endow self, factory: false`
+* The `.factory` method can be renamed with `Surrogate.endow self, factory: :custom_factory_method_name`
+* Allow mass initialization of clones with `MockClass.clone key: value`
+
 ### 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)

data/Readme.md

@@ -161,6 +161,8 @@ user.id # => 12
 ```
 
 Use **clone** to avoid altering state on the class.
+You can pass it key/value pairs to mass initialize the clone
+(I think it's probably best to avoid this kind of state on classes, but do support it)
 ```ruby
 class MockUser
   Surrogate.endow self do
@@ -168,12 +170,43 @@ class MockUser
   end
 end
 
+# using a clone
 user_class = MockUser.clone
 user_class.find
 user_class.was told_to :find
 MockUser.was_not told_to :find
+
+# initializing the clone
+MockUser.clone(find: nil).find.should be_nil
 ```
 
+**Mass initialize** with `.factory(key: value)`, this can be turned off by passing
+`factory: false` as an option to Surrogate.endow, or given a different name if
+the value is the new name.
+
+```ruby
+# default factory method
+class MockUserWithFactory
+  Surrogate.endow self
+  define(:name) { 'Samantha' }
+  define(:age)  { 83 }
+end
+
+user = MockUserWithFactory.factory name: 'Jim', age: 26
+user.name # => "Jim"
+user.age  # => 26
+
+# use a different name
+class MockUserWithoutFactory
+  Surrogate.endow self, factory: :construct
+  define(:name) { 'Samantha' }
+  define(:age)  { 83 }
+end
+
+user = MockUserWithoutFactory.construct name: 'Milla'
+user.name # => "Milla"
+user.age  # => 83
+```
 
 
 RSpec Integration

data/Readme.md.mountain_berry_fields

@@ -191,6 +191,8 @@ user.id # => 12
 ```
 
 Use **clone** to avoid altering state on the class.
+You can pass it key/value pairs to mass initialize the clone
+(I think it's probably best to avoid this kind of state on classes, but do support it)
 ```ruby
 <% test 'clone to avoid mutating state', with: :rspec, context: 'generic it block' do %>
 class MockUser
@@ -199,13 +201,46 @@ class MockUser
   end
 end
 
+# using a clone
 user_class = MockUser.clone
 user_class.find
 user_class.was told_to :find
 MockUser.was_not told_to :find
+
+# initializing the clone
+MockUser.clone(find: nil).find.should be_nil
 <% end %>
 ```
 
+**Mass initialize** with `.factory(key: value)`, this can be turned off by passing
+`factory: false` as an option to Surrogate.endow, or given a different name if
+the value is the new name.
+
+```ruby
+<% test 'factory method', with: :magic_comments do %>
+# default factory method
+class MockUserWithFactory
+  Surrogate.endow self
+  define(:name) { 'Samantha' }
+  define(:age)  { 83 }
+end
+
+user = MockUserWithFactory.factory name: 'Jim', age: 26
+user.name # => "Jim"
+user.age  # => 26
+
+# use a different name
+class MockUserWithoutFactory
+  Surrogate.endow self, factory: :construct
+  define(:name) { 'Samantha' }
+  define(:age)  { 83 }
+end
+
+user = MockUserWithoutFactory.construct name: 'Milla'
+user.name # => "Milla"
+user.age  # => 83
+<% end %>
+```
 
 
 RSpec Integration

data/lib/surrogate/api_comparer.rb

@@ -62,12 +62,22 @@ class Surrogate
 
     # there is a lot of duplication in these next four methods -.-
     # idk if there is something we can do about it.
+    #
+    # The class methods below ignore the .clone method, b/c it's interface is intentionally different.
+    # This is so stupid, it needs to get smarter, it needs a way for the Surrogate or the user to tell it
+    # what to care about, it shouldn't have to know about what the endower is doing.
+    #
+    # In general, this code is just really fucking bad. I'd like to create some sort of method object
+    # that can encapsulate all of this information (mthod name, param names, types, existence)
+    # but I can't quite see it yet, and I'm scared to refactor to it since this code is tested primarily
+    # through unit tests (this is one of the few places I resorted to unit tests, and I'm so unhappy that
+    # I did).
 
     # types are only shown for methods on both objects
     def class_types
       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
+        next if surrogate_type == actual_type || name == :clone # ugh :(
         hash[name] = { surrogate: surrogate_type, actual: actual_type }
       end
     end
@@ -85,7 +95,7 @@ class Surrogate
     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
+        next if surrogate_name == actual_name || method_name == :clone # ugh :(
         hash[method_name] = { surrogate: surrogate_name, actual: actual_name }
       end
     end

data/lib/surrogate/endower.rb

@@ -5,6 +5,14 @@ class Surrogate
   # please refactor me! ...may not be possible :(
   # Can we move all method definitions into this class?
   class Endower
+    def self.uninitialized_instance_for(surrogate_class)
+      instance = surrogate_class.allocate
+      hatchery = surrogate_class.instance_variable_get :@hatchery
+      surrogate_class.last_instance = instance
+      instance.instance_variable_set :@hatchling, Hatchling.new(instance, hatchery)
+      instance
+    end
+
     def self.add_hook(&block)
       hooks << block
     end
@@ -13,14 +21,14 @@ class Surrogate
       @hooks ||= []
     end
 
-    def self.endow(klass, &block)
-      new(klass, &block).endow
+    def self.endow(klass, options, &block)
+      new(klass, options, &block).endow
     end
 
-    attr_accessor :klass, :block
+    attr_accessor :klass, :block, :options
 
-    def initialize(klass, &block)
-      self.klass, self.block = klass, block
+    def initialize(klass, options, &block)
+      self.klass, self.options, self.block = klass, options, block
     end
 
     def endow
@@ -32,8 +40,9 @@ class Surrogate
 
     def endow_klass
       klass.extend ClassMethods
-      add_hatchery_to klass
+      add_hatchery_to klass, options # do we want to pick out which options to pass?
       enable_defining_methods klass
+      enable_factory          klass, options.fetch(:factory, :factory)
       klass.send :include, InstanceMethods
       enable_generic_override klass
       invoke_hooks klass
@@ -63,8 +72,8 @@ class Surrogate
       klass.singleton_class
     end
 
-    def add_hatchery_to(klass)
-      klass.instance_variable_set :@hatchery, Surrogate::Hatchery.new(klass)
+    def add_hatchery_to(klass, options={})
+      klass.instance_variable_set :@hatchery, Surrogate::Hatchery.new(klass, options)
     end
 
     def enable_defining_methods(klass)
@@ -72,6 +81,19 @@ class Surrogate
         @hatchery.define method_name, options, &block
       end
     end
+
+    def enable_factory(klass, factory_name)
+      return unless factory_name
+      klass.define_singleton_method factory_name do |overrides={}|
+        instance = begin
+                     new
+                   rescue ArgumentError
+                     Endower.uninitialized_instance_for self
+                   end
+        overrides.each { |attribute, value| instance.will_override attribute, value }
+        instance
+      end
+    end
   end
 
 
@@ -80,22 +102,21 @@ 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
+    def clone(overrides={})
       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
+        Surrogate.endow self, hatchery.options do
           hatchling.api_methods.each { |name, options| define name, options.to_hash, &options.default_proc }
         end
         hatchery.api_methods.each { |name, options| define name, options.to_hash, &options.default_proc }
+        overrides.each { |attribute, value| @hatchling.prepare_method attribute, [value] }
       end
     end
 
     # Custom new, because user can define initialize, and we need to record it
     def new(*args)
-      instance = allocate
-      self.last_instance = instance
-      instance.instance_variable_set :@hatchling, Hatchling.new(instance, @hatchery)
+      instance = Endower.uninitialized_instance_for self
       instance.__send__ :initialize, *args
       instance
     end

data/lib/surrogate/hatchery.rb

@@ -4,10 +4,14 @@ class Surrogate
   # The hatchlings are added to the instances, and they look here
   # to find out about how their methods are implemented.
   class Hatchery
-    attr_accessor :klass
 
-    def initialize(klass)
-      self.klass = klass
+    # currently options don't do anything,
+    # they're just there because the hatchery is the definition of the surrogate
+    # so it makes sense for it to store values used by the endower when constructing clones
+    attr_accessor :klass, :options
+
+    def initialize(klass, options)
+      self.klass, self.options = klass, options
       klass_can_define_api_methods
     end
 

data/lib/surrogate/version.rb

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

data/lib/surrogate.rb

@@ -10,8 +10,8 @@ require 'surrogate/invocation'
 class Surrogate
   UnpreparedMethodError = Class.new StandardError
 
-  def self.endow(klass, &block)
-    Endower.endow klass, &block
+  def self.endow(klass, options={},  &block)
+    Endower.endow klass, options, &block
     klass
   end
 end

data/spec/defining_api_methods_spec.rb

@@ -292,6 +292,17 @@ describe 'define' do
       superclass.clone.new.should be_a_kind_of superclass
     end
 
+    it 'can be mass initialized by passing a hash of attributes and values when cloning' do
+      pristine_klass = Surrogate.endow(Class.new) do
+        define(:find) { |n| 123 }
+        define(:bind) { 'abc' }
+      end
+      pristine_klass.clone.find(1).should == 123
+      pristine_klass.clone(find: 456, bind: 'def').find(1).should == 456
+      pristine_klass.clone.bind.should == 'abc'
+      pristine_klass.clone(find: 456, bind: 'def').bind.should == 'def'
+    end
+
     describe '.name' do
       it 'is nil for anonymous classes' do
         Surrogate.endow(Class.new).clone.name.should be_nil

data/spec/other_shit_spec.rb

@@ -183,3 +183,56 @@ describe 'inspect methods' do
     end
   end
 end
+
+describe '.factory' do
+  it 'allows you to initialize the values of the returned mock' do
+    klass = Surrogate.endow(Class.new).define(:a){'a'}.define(:b){'b'}
+    klass.factory(a: 'A').a.should == 'A'
+    klass.factory(a: 'A').b.should == 'b'
+    klass.new.a.should == 'a'
+  end
+
+  it 'can be turned off at the class level with Surrogate.endow self factory: false' do
+    klass = Surrogate.endow(Class.new, factory: false).define(:a) { 'a' }
+    expect { klass.factory a: 'A' }.to raise_error NoMethodError
+  end
+
+  it 'can be given a different method name by passing the name to the endower' do
+    klass = Surrogate.endow(Class.new, factory: :construct).define(:a) { 'a' }
+    expect { klass.factory a: 'A' }.to raise_error NoMethodError
+    klass.construct(a: 'A').a.should == 'A'
+  end
+
+  it 'retains its setting on clones' do
+    clone = Surrogate.endow(Class.new, factory: :construct).define(:a){'a'}.clone
+    expect { clone.factory a: 'A' }.to raise_error NoMethodError
+    clone.construct(a: 'A').a.should == 'A'
+    clone.new.a.should == 'a'
+  end
+
+  context 'when the initialize method can be invoked without args' do
+    let(:klass)    { Surrogate.endow(Class.new).define(:initialize) { } }
+    let!(:instance) { klass.factory }
+
+    it 'is invoked' do
+      instance.was initialized_with no_args
+    end
+
+    specify 'the instance is recorded as the last instance' do
+      klass.last_instance.should == instance
+    end
+  end
+
+  context 'when the initialize method cannot be invoked without args' do
+    let(:klass)    { Surrogate.endow(Class.new).define(:initialize) {|arg|} }
+    let!(:instance) { klass.factory }
+
+    it 'is NOT invoked' do
+      instance.was_not told_to :initialize
+    end
+
+    specify 'the instance is recorded as the last instance' do
+      klass.last_instance.should == instance
+    end
+  end
+end

data/todo

@@ -10,6 +10,7 @@ Urgent (things I want to do immediately, formatted as the git commits I will use
 TODO (next up after urgent, these will happen whenever I get around to it)
 --------------------------------------------------------------------------
 
+* when trying to set a return value, error is NoMethodError will_have_whatever, but would be nice for it to say `UndefinedMethodError bad_stuff is not defined`
 * 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

metadata

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