prefactory 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 013e5ed5e0804fcc19fa994c3d64c0a1e4cede1d
-  data.tar.gz: 553cc7b243284a49b97b247ee4b7d00a79904af8
+  metadata.gz: 0f879df086b73a9de646cc17f9a1f994d888957b
+  data.tar.gz: a8232c6538a32d3de8e65acb24ba1ff5cb7de924
 SHA512:
-  metadata.gz: 79fdb0a121681e05a0d0617b5bb5b840da87c3442a6a64c363094c765d453b860aba29d10ccc3f142824e0710c61925c873fe687df5142b1e10ef19a49811e69
-  data.tar.gz: d5f7469e71a6ffd0a60006905ee245c7aca644bd2753c1cd7fb6dee1eae8b6d2e0a091d67d6aa6f9d9568a95dc5d8c527e97534f872b2abdd635505900ec2f83
+  metadata.gz: 03e35db9745634b13cc2d87a5f7beb8bde287b8962da5256a64f10b5f5d09897034c8cf355f10e8282873c73fb2b6e570f4f9e84918ad1f7c7c46355484db7bc
+  data.tar.gz: d21a6f09b96f915bd3382c84b13521b1203a11d9986dea71002b19370e5e00d7f7d072af9544a8fab88e7e8dbc90a117d6b72a803f4694ade6d5823a090ea8cc

data/README.md

@@ -103,6 +103,16 @@ end
 
 See also:  [An example rails application with Prefactory configured](https://github.com/seanwalbran/prefactory-example)
 
+If desired, it is also possible to only include the `set!` method and related
+lookup functionality for e.g. specs that cannot use transactional isolation
+(like some threaded Capybara feature specs, or similar):
+
+```ruby
+RSpec.configure do |config|
+  config.include Prefactory::Lookups
+end
+```
+
 ## Contributing
 
 1. Fork it ( http://github.com/socialcast/prefactory/fork )

data/lib/prefactory/version.rb

@@ -21,5 +21,5 @@
 # SOFTWARE.
 
 module Prefactory
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/rspec/core/prefactory.rb

@@ -29,156 +29,169 @@ module Prefactory
   class NotDefined
   end
 
-  def prefactory_lookup(key)
-    PrefactoryLookup.where(:key => key).first
-  end
-
-  # instantiate, or access an already-instantiated-and-memoized, prefabricated object.
-  def prefactory(key)
-    @prefactory_memo ||= {}
-    @prefactory_memo[key] ||= begin
-                                lookup = prefactory_lookup(key)
-                                if lookup.present?
-                                  if lookup[:result_class]
-                                    lookup[:result_class].constantize.find(lookup[:result_id])
-                                  else
-                                    YAML.load(lookup[:result_value])
-                                  end
-                                else
-                                  Prefactory::NotDefined
-                                end
-                              rescue
-                              end
+  def self.included(base)
+    base.include Transactionality
+    base.include Lookups
   end
 
-  def in_before_all?
-    @before_all_context
-  end
+  module Lookups
+    def self.included(base)
+      PrefactoryLookup.create_table
+
+      base.instance_eval do
+        def before_with_detect_before_all(*args, &block)
+          before_all_context = (args.first == :all)
+          modified_block = proc do
+            @before_all_context = before_all_context
+            instance_eval(&block)
+            @before_all_context = nil
+          end
+          before_without_detect_before_all(*args, &modified_block)
+        end
 
-  # prefabricate an object.  Can be passed any block that returns a class accessible by Klass.find(id),
-  # or, if no block is passed, invokes create(key, options) to use e.g. a FactoryGirl factory of that key name.
-  def prefactory_add(key, *args, &block)
-    raise "prefactory_add can only be used in a before(:all) context.  Change to a before(:all) or set!, or use let/let! instead." unless in_before_all?
-    result = nil
-    clear_prefactory_memoizations
-    if block
-      result = yield
-    else
-      result = create(key, *args) if respond_to?(:create)
-    end
-    if result.present?
-      if result.respond_to?(:id)
-        PrefactoryLookup.where(:key => key).first_or_initialize.tap do |lookup|
-          lookup.result_class = result.class.name
-          lookup.result_id = result.id
-          lookup.result_value = nil
-          lookup.save!
+        class << self
+          alias_method :before_without_detect_before_all, :before
+          alias_method :before, :before_with_detect_before_all
         end
-      else
-        PrefactoryLookup.where(:key => key).first_or_initialize.tap do |lookup|
-          lookup.result_class = nil
-          lookup.result_id = nil
-          lookup.result_value = YAML.dump(result)
-          lookup.save!
+
+        def set!(key, *args, &set_block)
+          before(:all) do
+            modified_block = proc { instance_eval(&set_block) } if set_block
+            prefactory_add(key, *args, &modified_block)
+          end
         end
       end
-    else
-      warn "WARNING: Failed to add #{key} to prefactory: block result not present"
-    end
-    clear_prefactory_memoizations
-    result
-  end
-
-  def self.included(base)
-    base.extend RSpecAroundAll
-    PrefactoryLookup.create_table
 
-    # Wrap outermost describe block in a transaction, so before(:all) data is rolled back at the end of this suite.
-    base.before(:all) do
-      clear_prefactory_memoizations
-    end
-    base.around(:all) do |group|
-      ActiveRecord::Base.with_disposable_transaction { group.run_examples }
-    end
-    base.after(:all) do
-      clear_prefactory_memoizations
+      # allow shorthand access to a prefabricated object
+      # e.g. with prefactory_add(:active_user), calling the method active_user will return the (memoized) object,
+      # by invoking the 'prefactory' method.
+      base.class_eval do
+        def method_missing(key, *args, &block)
+          result = prefactory(key)
+          result == Prefactory::NotDefined ? super : result
+        end
+      end
     end
 
-    # Wrap each example in a transaction, instead of using Rails' transactional
-    # fixtures, which does not support itself being wrapped in an outermost transaction.
-    base.around(:each) do |example|
-      clear_prefactory_memoizations
-      ActiveRecord::Base.with_disposable_transaction { example.run }
-      clear_prefactory_memoizations
+    def prefactory_lookup(key)
+      PrefactoryLookup.where(:key => key).first
     end
 
-    # Wrap each ExampleGroup in a transaction, so group-level before(:all) settings
-    # are scoped only to the group.
-    base.instance_eval do
-      def describe_with_transaction(*args, &block)
-        original_caller = caller
-        modified_block = proc do
-          instance_eval do
-            before(:all) { clear_prefactory_memoizations }
-            around(:all) do |group|
-              ActiveRecord::Base.with_disposable_transaction { group.run_examples }
-            end
-            after(:all) { clear_prefactory_memoizations }
+    # instantiate, or access an already-instantiated-and-memoized, prefabricated object.
+    def prefactory(key)
+      @prefactory_memo ||= {}
+      @prefactory_memo[key] ||= begin
+        lookup = prefactory_lookup(key)
+        if lookup.present?
+          if lookup[:result_class]
+            lookup[:result_class].constantize.find(lookup[:result_id])
+          else
+            YAML.load(lookup[:result_value])
           end
-          instance_eval(&block)
-        end
-
-        caller_metadata = { :caller => original_caller }
-        if args.last.is_a?(Hash)
-          args.last.merge!(caller_metadata)
         else
-          args << caller_metadata
+          Prefactory::NotDefined
         end
-
-        describe_without_transaction(*args, &modified_block)
+      rescue
       end
+    end
 
-      def before_with_detect_before_all(*args, &block)
-        before_all_context = (args.first == :all)
-        modified_block = proc do
-          @before_all_context = before_all_context
-          instance_eval(&block)
-          @before_all_context = nil
-        end
-        before_without_detect_before_all(*args, &modified_block)
-      end
+    def in_before_all?
+      @before_all_context
+    end
 
-      class << self
-        alias_method_chain :describe, :transaction
-        alias_method :context, :describe
-        alias_method_chain :before, :detect_before_all
+    # prefabricate an object.  Can be passed any block that returns a class accessible by Klass.find(id),
+    # or, if no block is passed, invokes create(key, options) to use e.g. a FactoryGirl factory of that key name.
+    def prefactory_add(key, *args, &block)
+      raise "prefactory_add can only be used in a before(:all) context.  Change to a before(:all) or set!, or use let/let! instead." unless in_before_all?
+      result = nil
+      clear_prefactory_memoizations
+      if block
+        result = yield
+      else
+        result = create(key, *args) if respond_to?(:create)
       end
-
-      def set!(key, *args, &set_block)
-        before(:all) do
-          modified_block = proc { instance_eval(&set_block) } if set_block
-          prefactory_add(key, *args, &modified_block)
+      if result.present?
+        if result.respond_to?(:id)
+          PrefactoryLookup.where(:key => key).first_or_initialize.tap do |lookup|
+            lookup.result_class = result.class.name
+            lookup.result_id = result.id
+            lookup.result_value = nil
+            lookup.save!
+          end
+        else
+          PrefactoryLookup.where(:key => key).first_or_initialize.tap do |lookup|
+            lookup.result_class = nil
+            lookup.result_id = nil
+            lookup.result_value = YAML.dump(result)
+            lookup.save!
+          end
         end
+      else
+        warn "WARNING: Failed to add #{key} to prefactory: block result not present"
       end
+      clear_prefactory_memoizations
+      result
+    end
 
+    def clear_prefactory_memoizations
+      @prefactory_memo = {}
     end
+  end
 
-    # allow shorthand access to a prefabricated object
-    # e.g. with prefactory_add(:active_user), calling the method active_user will return the (memoized) object,
-    # by invoking the 'prefactory' method.
-    base.class_eval do
-      def method_missing(key, *args, &block)
-        result = prefactory(key)
-        result == Prefactory::NotDefined ? super : result
+  module Transactionality
+    def self.included(base)
+      base.extend RSpecAroundAll
+      # Wrap outermost describe block in a transaction, so before(:all) data is rolled back at the end of this suite.
+      base.before(:all) do
+        clear_prefactory_memoizations
+      end
+      base.around(:all) do |group|
+        ActiveRecord::Base.with_disposable_transaction { group.run_examples }
+      end
+      base.after(:all) do
+        clear_prefactory_memoizations
       end
-    end
 
-  end
+      # Wrap each example in a transaction, instead of using Rails' transactional
+      # fixtures, which does not support itself being wrapped in an outermost transaction.
+      base.around(:each) do |example|
+        clear_prefactory_memoizations
+        ActiveRecord::Base.with_disposable_transaction { example.run }
+        clear_prefactory_memoizations
+      end
 
-  private
+      # Wrap each ExampleGroup in a transaction, so group-level before(:all) settings
+      # are scoped only to the group.
+      base.instance_eval do
+        def describe_with_transaction(*args, &block)
+          original_caller = caller
+          modified_block = proc do
+            instance_eval do
+              before(:all) { clear_prefactory_memoizations }
+              around(:all) do |group|
+                ActiveRecord::Base.with_disposable_transaction { group.run_examples }
+              end
+              after(:all) { clear_prefactory_memoizations }
+            end
+            instance_eval(&block)
+          end
 
-  def clear_prefactory_memoizations
-    @prefactory_memo = {}
-  end
+          caller_metadata = { :caller => original_caller }
+          if args.last.is_a?(Hash)
+            args.last.merge!(caller_metadata)
+          else
+            args << caller_metadata
+          end
 
+          describe_without_transaction(*args, &modified_block)
+        end
+
+        class << self
+          alias_method :describe_without_transaction, :describe
+          alias_method :describe, :describe_with_transaction
+          alias_method :context, :describe
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefactory
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - developers@socialcast.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec_around_all