once-ler 0.0.11 → 0.0.12

data/README.md

@@ -52,6 +52,47 @@ describe "something" do
 end
 ```
 
+## Configuration
+
+once-ler adds two new `before`/`after` scopes, `:record` and `:reset`, in
+case you need to implement additional logic. `:record` runs in
+conjunction with once-ler's recording phase (the implicit `before :all`).
+`:reset` runs in conjunction with its cleanup phase (database rollback,
+implicit `after :all`). As oppose to `:all`/`:context` hooks, these ones
+are inherited down, and will run before/after any nested once-ler setup/
+teardown.`
+
+They can be used globally, or in a particular group. For example:
+
+```ruby
+Onceler.configure do |config|
+  config.before :record do
+    # reset some caching to ensure all recordings get a blank slate
+  end
+end
+
+describe Foo do
+  before(:record) { Foo.stubs(:enabled?).returns(true) }
+  after(:record)  { Foo.unstub(:enabled?) } # can't serialize stubs
+  before(:each)   { Foo.stubs(:enabled?).returns(true) }
+
+  context "lol" do
+    before :once do
+      # something that needs the stub to work
+    end
+    # ...
+  end
+
+  context "wut" do
+    it do
+      # something that needs the stub to work
+    end
+  end
+
+  # ...
+end
+```
+
 ## How much of a speedup will I get?
 
 YMMV, it depends on how bad your `let`s/`before`s are. For example,
@@ -63,7 +104,7 @@ model specs (spec/models/a*) **reduces their runtime by 40%**.
 Any `before(:once)`/`let_once` blocks will run just once for the current
 context/describe block, before any of its examples run. Any side effects
 (ivars) and return values will be recorded, and will then be reapplied
-before each spec in the block runs. Once-ler uses nested transactions
+before each spec in the block runs. once-ler uses nested transactions
 (savepoints) to ensure that specs don't mess with each other's database
 rows.
 
@@ -79,9 +120,10 @@ of activerecord callbacks/inserts/updates.
   statements, return values, and instance variables.
 * 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.
+     RSpec mocks/doubles can't.
+  1. should implement `#==`. 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
+     go override `Object#==`
 * 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

data/lib/onceler/ambitious_helpers.rb

@@ -1,8 +1,8 @@
 module Onceler
   module AmbitiousHelpers
     # make :once the default behavior for before/let/etc.
-    def once_scope?(scope)
-      super || scope.nil?
+    def once_scopes
+      [:once, nil]
     end
   end
 end

data/lib/onceler/basic_helpers.rb

@@ -31,8 +31,8 @@ module Onceler
         onceler(:create) << block
       end
 
-      def once_scope?(scope)
-        scope == :once
+      def once_scopes
+        [:once]
       end
 
       # add second scope argument to explicitly differentiate between
@@ -40,7 +40,7 @@ module Onceler
       [:let, :let!, :subject, :subject!].each do |method|
         once_method = (method.to_s.sub(/!\z/, '') + "_once").to_sym
         define_method(method) do |name = nil, scope = nil, &block|
-          if once_scope?(scope)
+          if once_scopes.include?(scope)
             send once_method, name, &block
           else
             super name, &block
@@ -59,13 +59,27 @@ module Onceler
       end
 
       def before(*args, &block)
-        if once_scope?(args.first)
+        scope = args.first
+        case scope
+        when :record, :reset
+          onceler(:create).hooks[:before][scope] << block
+        when *once_scopes
           before_once(&block)
         else
           super(*args, &block)
         end
       end
 
+      def after(*args, &block)
+        scope = args.first
+        case scope
+        when :record, :reset
+          onceler(:create).hooks[:after][scope] << block
+        else
+          super
+        end
+      end
+
       def onceler(create_own = false)
         if create_own
           @onceler ||= create_onceler!
@@ -88,7 +102,6 @@ module Onceler
 
       def add_onceler_hooks!
         before(:all) do |group|
-          Onceler.configuration.run_callbacks(:record, :before)
           group.onceler.record!
         end
 

data/lib/onceler/configuration.rb

@@ -9,19 +9,24 @@ module Onceler
 
   class Configuration
     def before(scope, &block)
-      callbacks[scope][:before] << block
+      hooks[:before][scope] << block
     end
 
-    def callbacks
-      @callbacks ||= Hash.new do |scopes, scope|
-        scopes[scope] = Hash.new do |timings, timing|
-          timings[timing] = []
-        end
-      end
+    def after(scope, &block)
+      hooks[:before][scope] << block
+    end
+
+    def hooks
+      @hooks ||= {
+        before: {record: [], reset: []},
+        after:  {record: [], reset: []}
+      }
     end
 
-    def run_callbacks(scope, timing)
-      callbacks[scope][timing].each(&:call)
+    def run_hooks(timing, scope, context)
+      hooks[timing][scope].each do |hook|
+        context ? context.instance_eval(&hook) : hook.call
+      end
     end
   end
 end

data/lib/onceler/recorder.rb

@@ -55,6 +55,7 @@ module Onceler
         @tape.copy_from(parent.tape)
       end
 
+      run_before_hooks(:record, @tape)
       # we don't know the order named recordings will be called (or if
       # they'll call each other), so prep everything first
       @recordings.each do |recording|
@@ -63,19 +64,51 @@ module Onceler
       @recordings.each do |recording|
         recording.record_onto!(@tape)
       end
+      run_after_hooks(:record, @tape)
       @data = @tape.__data
     ensure
       Onceler.recording = false
     end
 
     def reset!
+      run_before_hooks(:reset)
       rollback_transactions!
+      run_after_hooks(:reset)
     end
 
     def parent
       @group_class.parent_onceler
     end
 
+    def hooks
+      @hooks ||= {
+        before: {record: [], reset: []},
+        after:  {record: [], reset: []}
+      }
+    end
+
+    def run_before_hooks(scope, context = nil)
+      if parent
+        parent.run_before_hooks(scope, context)
+      else
+        Onceler.configuration.run_hooks(:before, scope, context)
+      end
+      hooks[:before][scope].each do |hook|
+        context ? context.instance_eval(&hook) : hook.call
+      end
+    end
+
+    def run_after_hooks(scope, context = nil)
+      hooks[:after][scope].each do |hook|
+        context ? context.instance_eval(&hook) : hook.call
+      end
+      if parent
+        parent.run_before_hooks(scope, context)
+      else
+        Onceler.configuration.run_hooks(:after, scope, context)
+      end
+    end
+
     def replay_into!(instance)
       @ivars, @retvals = Marshal.load(@data)
       @ivars.each do |key, value|

metadata

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