once-ler 0.0.2 → 0.0.3

data/README.md

@@ -30,17 +30,25 @@ Change a slow `before` to `before(:once)` to speed it up.
 
 Change a slow `let` (or `let!`) to `let_once` to speed it up.
 
+### subject_once(...) { ... }
+
+Change a slow `subject` (or `subject!`) to `subject_once` to speed it up.
+
 ## Ambitious usage
 
 If you're feeling bold, you can automatically speed up all
-`let`s/`before(:each)`s in an example group:
+`let`s/`before`s in an example group:
 
 ```ruby
 describe "something" do
   onceler!
-  let(:foo) { ... }    # behaves like let_once
-  before { ... }       # behaves like before(:once)
-  before(:all) { ... } # no change here though
+
+  let(:foo) { ... }      # behaves like let_once
+  before { ... }         # behaves like before(:once)
+
+  # but if you need explict eaches, you can still do them:
+  let_each(:foo) { ... }
+  before(:each) { ... }
 end
 ```
 
@@ -66,6 +74,9 @@ of activerecord callbacks/inserts/updates.
 
 ## Caveats
 
+* If you are doing anything database-y, you need to use transactional
+  tests (either via `use_transactional_fixtures=true`, or something like
+  [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

data/lib/onceler/ambitious_helpers.rb

@@ -1,39 +1,8 @@
 module Onceler
   module AmbitiousHelpers
-    def before_once?(type)
-      super || type == :each || type.nil?
-    end
-
-    def let(name, &block)
-      let_once(name, &block)
-    end
-
-    # TODO NamedSubjectPreventSuper
-    def subject(name = nil, &block)
-      subject_once(name, &block)
-    end
-
-    # remove auto-before'ing of ! methods, since we memoize our own way
-    def let!(name, &block)
-      let(name, &block)
-    end
-
-    def subject!(name = nil, &block)
-      subject(name, &block)
-    end
-
-    # make sure we have access to subsequently added methods when
-    # recording (not just `lets'). note that this really only works
-    # for truly functional methods with no external dependencies. e.g.
-    # methods that add stubs or set instance variables will not work
-    # while recording
-    def method_added(method_name)
-      return if method_name == @current_let_once
-      onceler = onceler(:create)
-      proxy = onceler.helper_proxy ||= new
-      onceler.helper_methods[method_name] ||= Proc.new do |*args|
-        proxy.send method_name, *args
-      end
+    # make :once the default behavior for before/let/etc.
+    def once_scope?(scope)
+      super || scope.nil?
     end
   end
 end

data/lib/onceler/basic_helpers.rb

@@ -1,5 +1,4 @@
 require "onceler/ambitious_helpers"
-require "onceler/around_all"
 require "onceler/recorder"
 
 module Onceler
@@ -13,15 +12,15 @@ module Onceler
     end
 
     module ClassMethods
-      include AroundAll
-
       def let_once(name, &block)
+        raise ArgumentError, "wrong number of arguments (0 for 1)" if name.nil?
         raise "#let or #subject called without a block" if block.nil?
         onceler(:create)[name] = block
         @current_let_once = name
         define_method(name) { onceler[name] }
       end
 
+      # TODO NamedSubjectPreventSuper
       def subject_once(name = nil, &block)
         name ||= :subject
         let_once(name, &block)
@@ -32,12 +31,35 @@ module Onceler
         onceler(:create) << block
       end
 
-      def before_once?(type)
-        type == :once
+      def once_scope?(scope)
+        scope == :once
+      end
+
+      # add second scope argument to explicitly differentiate between
+      # :each / :once
+      [: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)
+            send once_method, name, &block
+          else
+            super name, &block
+          end
+        end
+      end
+
+      # set up let_each, etc.
+      [:let, :let!, :subject, :subject!].each do |method|
+        each_method = method.to_s
+        bang = each_method.sub!(/!\z/, '')
+        each_method = (each_method + "_each" + (bang ? "!" : "")).to_sym
+        define_method(each_method) do |name = nil, &block|
+          send method, name, &block
+        end
       end
 
       def before(*args, &block)
-        if before_once?(args.first)
+        if once_scope?(args.first)
           before_once(&block)
         else
           super(*args, &block)
@@ -57,6 +79,20 @@ module Onceler
         Recorder.new(parent_onceler)
       end
 
+      # make sure we have access to subsequently added methods when
+      # recording (not just `lets'). note that this really only works
+      # for truly functional methods with no external dependencies. e.g.
+      # methods that add stubs or set instance variables will not work
+      # while recording
+      def method_added(method_name)
+        return if method_name == @current_let_once
+        return if !@onceler
+        proxy = onceler.helper_proxy ||= new
+        onceler.helper_methods[method_name] ||= Proc.new do |*args|
+          proxy.send method_name, *args
+        end
+      end
+
       private
 
       def parent_onceler
@@ -65,18 +101,17 @@ module Onceler
       end
 
       def add_onceler_hooks!
-        around_all do |group|
-          # TODO: configurable transaction fu (say, if you have multiple
-          # conns)
-          ActiveRecord::Base.transaction(requires_new: true) do
-            group.onceler.record!
-            group.run_examples
-            raise ActiveRecord::Rollback
-          end
+        prepend_before(:all) do |group|
+          group.onceler.record!
         end
+
+        after(:all) do |group|
+          group.onceler.reset!
+        end
+
         # only the outer-most group needs to do this
         unless parent_onceler
-          register_hook :append, :before, :each do
+          before :each do
             onceler.replay_into!(self)
           end
         end

data/lib/onceler/recorder.rb

@@ -1,4 +1,5 @@
 require "onceler/blank_tape"
+require "active_record"
 
 module Onceler
   class Recorder
@@ -24,6 +25,7 @@ module Onceler
     end
 
     def record!
+      begin_transactions!
       @tape = @parent ? @parent.tape.copy(mixins) : BlankTape.new(mixins)
       proxy_recordable_methods!
 
@@ -38,6 +40,10 @@ module Onceler
       @data = Marshal.dump(@tape.__data)
     end
 
+    def reset!
+      rollback_transactions!
+    end
+
     def proxy_recordable_methods!
       # the proxy is used to run non-recordable methods that may be called
       # by ones are recording. since the former could in turn call more of
@@ -92,6 +98,57 @@ module Onceler
         instance.instance_variable_set(key, value)
       end
     end
+
+    # TODO: configurable transaction fu (say, if you have multiple
+    # conns)
+    def transaction_classes
+      [ActiveRecord::Base]
+    end
+
+    def begin_transactions!
+      transaction_classes.each do |klass|
+        begin_transaction(klass.connection)
+      end
+    end
+
+    def rollback_transactions!
+      transaction_classes.each do |klass|
+        rollback_transaction(klass.connection)
+      end
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+      def begin_transaction(conn)
+        conn.begin_transaction requires_new: true
+      end
+
+      def rollback_transaction(conn)
+        conn.rollback_transaction
+      end
+    else
+      def begin_transaction(klass)
+        unless conn.instance_variable_get(:@_current_transaction_records)
+          conn.instance_variable_set(:@_current_transaction_records, [])
+        end
+        if conn.open_transactions == 0
+          conn.begin_db_transaction
+        else
+          conn.create_savepoint
+        end
+        conn.increment_open_transactions
+      end
+
+      def begin_transaction(klass)
+        conn.decrement_open_transactions
+        if conn.open_transactions == 0
+          conn.rollback_db_transaction
+          conn.send :rollback_transaction_records, true
+        else
+          conn.rollback_to_savepoint
+          conn.send :rollback_transaction_records, false
+        end
+      end
+    end
   end
 
   class Recording

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: once-ler
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2014-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,7 +53,6 @@ files:
 - README.md
 - lib/once-ler.rb
 - lib/onceler/ambitious_helpers.rb
-- lib/onceler/around_all.rb
 - lib/onceler/basic_helpers.rb
 - lib/onceler/blank_tape.rb
 - lib/onceler/configuration.rb

data/lib/onceler/around_all.rb

@@ -1,32 +0,0 @@
-# adapted from https://gist.github.com/myronmarston/2005175
-require 'delegate'
-require 'fiber'
-
-module Onceler
-  module AroundAll
-    class FiberAwareGroup < SimpleDelegator
-      def run_examples
-        Fiber.yield
-      end
-
-      def to_proc
-        proc { run_examples }
-      end
-    end
-
-    def around_all(&block)
-      fibers = []
-      prepend_before(:all) do |group|
-        fiber = Fiber.new(&block)
-        fibers << fiber
-        fiber.resume(FiberAwareGroup.new(group))
-      end
-
-      after(:all) do |group|
-        fiber = fibers.pop
-        fiber.resume if fiber.alive?
-      end
-    end
-  end
-end
-