once-ler 0.0.10 → 0.0.11

data/README.md

@@ -52,14 +52,6 @@ describe "something" do
 end
 ```
 
-Or even more ambitiously, apply it to all your specs:
-
-```ruby
-RSpec.configure do |c|
-  c.onceler!
-end
-```
-
 ## How much of a speedup will I get?
 
 YMMV, it depends on how bad your `let`s/`before`s are. For example,
@@ -85,8 +77,11 @@ of activerecord callbacks/inserts/updates.
   [database_cleaner](https://github.com/DatabaseCleaner/database_cleaner))
 * Your once'd blocks should have no side effects other than database
   statements, return values, and instance variables.
-* Your return values and instance variables need to be able to handle a
-  Marshal.dump/load round trip.
+* Your return values and instance variables:
+  1. need to be able to handle a `Marshal.dump`/`load` round trip.
+  1. should implement `#==` and `#hash`. for built-ins types (e.g. String)
+     or models, this isn't a problem, but if it's a custom class you might
+     need to add them.
 * Your once'd blocks' behavior should not depend on side effects of other
   non-once'd blocks. For example:
   * a `before(:once)` block should not reference instance variables set by a
@@ -96,27 +91,3 @@ of activerecord callbacks/inserts/updates.
   in a particular example), you should ensure they don't conflict with
   each other (e.g. unique constraint violations, or one `let_once`
   mutating the return value of another).
-* Some effort is made to preserve object identity, but just for instance
-  variables and return values, e.g.:
-
-  ```ruby
-    let_once(:user) { User.new }
-    let_once(:users) { [user] }
-
-    before(:once) do
-      @joe = user
-      @also_joe = @joe
-      @joe_ish = [@joe]
-    end
-
-    # within an example:
-    # user == @joe             => true
-    # user.equal? @joe         => true # yay
-    # user == @also_joe        => true
-    # user.equal? @also_joe    => true # yay
-    # user == users[0]         => true
-    # user.equal? users[0]     => false # d'oh
-    # user == @joe_ish[0]      => true
-    # user.equal? @joe_ish[0]  => false # d'oh
-  ```
-

data/lib/onceler/recordable.rb

@@ -45,17 +45,44 @@ module Onceler
     # we don't include inherited stuff in __data, because we might need to
     # interleave things from an intermediate before(:each) at run time
     def __mutated?(key, val)
+      # top-level recorders don't inherit anything, so we always want to return true
       return true unless @__inherited_cache
       # need to do both types of comparison, i.e. it's the same object in
       # memory (not reassigned), and nothing about it has been changed
-      return false if @__inherited_values.equal?(val)
-      return false if @__inherited_cache[key] == val
-      true
+      return true unless @__inherited_values[key].equal?(val)
+      return true unless __values_equal?(@__inherited_cache[key], val)
+      false
+    end
+
+    def __values_equal?(obj1, obj2)
+      if ActiveRecord::Base === obj1 && ActiveRecord::Base === obj2
+        cache_key = [obj1, obj2]
+        return @__comparison_cache[cache_key] if @__comparison_cache.key?(cache_key)
+        # so as to avoid cycles while traversing AR associations
+        @__comparison_cache[cache_key] = true
+        @__comparison_cache[cache_key] = obj1.attributes == obj2.attributes &&
+                                         __associations_equal?(obj1, obj2)
+      else
+        obj1 == obj2
+      end
+    end
+
+    # if a nested once block updates an inherited object's associations,
+    # we want to know about it
+    def __associations_equal?(obj1, obj2)
+      cache1 = obj1.instance_variable_get(:@association_cache)
+      cache2 = obj2.instance_variable_get(:@association_cache)
+      cache1.all? { |k, v| __values_equal?(v.target, cache2[k].target) }
     end
 
     def __data(inherit = false)
       @__data ||= {}
-      @__data[inherit] ||= Marshal.dump([__ivars(inherit), __retvals(inherit)])
+      @__data[inherit] ||= begin
+        @__comparison_cache = {}
+        data = Marshal.dump([__ivars(inherit), __retvals(inherit)])
+        @__comparison_cache = nil
+        data
+      end
     end
 
     def copy_from(other)

data/lib/onceler/recorder.rb

@@ -72,33 +72,15 @@ module Onceler
       rollback_transactions!
     end
 
-    def reconsitute_data!
-      @ivars, @retvals = Marshal.load(@data)
-      identity_map = {}
-      reidentify!(@ivars, identity_map)
-      reidentify!(@retvals, identity_map)
-    end
-
-    def reidentify!(hash, identity_map)
-      hash.each do |key, value|
-        if identity_map.key?(value)
-          hash[key] = identity_map[value]
-        else
-          identity_map[value] = value
-        end
-      end
-    end
-
     def parent
       @group_class.parent_onceler
     end
 
     def replay_into!(instance)
-      reconsitute_data!
+      @ivars, @retvals = Marshal.load(@data)
       @ivars.each do |key, value|
         instance.instance_variable_set(key, value)
       end
-      @retvals
     end
 
     # TODO: configurable transaction fu (say, if you have multiple

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: once-ler
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord