activerecord-transactionable 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cdd81b65018bf33891cc544fe49c84e135e11cc6
-  data.tar.gz: 05ef7ae436dfb6209334b5c34e7236983c1aea0d
+  metadata.gz: 838f13e51d720bccaec065d8c435ff17cfa6464e
+  data.tar.gz: 02a5eb9919b324c95a7d1cad51661aa7bac9ff87
 SHA512:
-  metadata.gz: cec4d15f0088a1cc2027f16cb98917a98de1e8ef57cb83af99d61355e71d011841ba19457f10747eeb7846709b02a032d3771aecb862782da171798aface8b78
-  data.tar.gz: d766492135b7c457c0d2152061f457c8fe5fd4e030ec324b829fdb63c3d8e70c0e5396764d5324a367d63af29f6e9ea6dd3eb45399e94b526a8a64bf6401c375
+  metadata.gz: 4af2e50720c55e48e3a2859048d219bc4d6284564112fa27cc699a69456fc92f198d5c78bb474441ce41de36499e01a50c2b07b5355a16e2676fb8312e3b1a2b
+  data.tar.gz: 2e92369926fc990d3ea2edf7c6faab25e6934dd299ad75d7012a2e2d0eb32c4949bb4c56ebcd9221168ea4e7c136c858abbdf1e496f5c07e45d70a15e6d728e6

data/lib/activerecord/transactionable.rb

@@ -13,8 +13,37 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
   module Transactionable
     extend ActiveSupport::Concern
 
-    DEFAULT_ERRORS_TO_HANDLE = [ActiveRecord::RecordInvalid]
-    DEFAULT_ERRORS_WHICH_PREPARE_ERRORS_ON_SELF = [ActiveRecord::RecordInvalid]
+    DEFAULT_ERRORS_TO_HANDLE_INSIDE_TRANSACTION = []
+    DEFAULT_ERRORS_PREPARE_ON_SELF_INSIDE = []
+    DEFAULT_ERRORS_TO_HANDLE_OUTSIDE_TRANSACTION = [ ActiveRecord::RecordInvalid ]
+    DEFAULT_ERRORS_PREPARE_ON_SELF_OUTSIDE = [ ActiveRecord::RecordInvalid ]
+    # These errors (and possibly others) will invalidate the transaction (on PostgreSQL and possibly other databases).
+    # This means that if you did rescue them inside a transaction (or a nested transaction) all subsequent queries would fail.
+    ERRORS_TO_DISALLOW_INSIDE_TRANSACTION = [
+        ActiveRecord::RecordInvalid,
+        ActiveRecord::StatementInvalid,
+        ActiveRecord::RecordNotUnique
+    ].freeze
+    # http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-transaction
+    TRANSACTION_METHOD_ARG_NAMES = [
+        :requires_new,
+        :isolation,
+        :joinable
+    ].freeze
+    INSIDE_TRANSACTION_ERROR_HANDLERS = [
+        :rescued_errors,
+        :prepared_errors,
+        :retriable_errors,
+        :reraisable_errors
+    ].freeze
+    OUTSIDE_TRANSACTION_ERROR_HANDLERS = [
+        :outside_rescued_errors,
+        :outside_prepared_errors,
+        :outside_retriable_errors,
+        :outside_reraisable_errors
+    ].freeze
+    INSIDE_CONTEXT = "inside".freeze
+    OUTSIDE_CONTEXT = "outside".freeze
 
     def transaction_wrapper(**args)
       self.class.transaction_wrapper(object: self, **args) do
@@ -24,78 +53,166 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
 
     module ClassMethods
       def transaction_wrapper(object: nil, **args)
+        lock = args.delete(:lock)
+        inside_args = extract_args(args, INSIDE_TRANSACTION_ERROR_HANDLERS)
+        outside_args = extract_args(args, OUTSIDE_TRANSACTION_ERROR_HANDLERS)
+        transaction_open = ActiveRecord::Base.connection.transaction_open?
+        raise ArgumentError, "#{self} does not know how to handle arguments: #{args.keys.inspect}" unless args.keys.empty?
+        if ERRORS_TO_DISALLOW_INSIDE_TRANSACTION.detect { |error| inside_args.values.include?(error) }
+          raise ArgumentError, "#{self} should not rescue #{ERRORS_TO_DISALLOW_INSIDE_TRANSACTION.inspect} inside a transaction: #{args.keys.inspect}"
+        end
+        transaction_args = extract_args(args, TRANSACTION_METHOD_ARG_NAMES)
+        if transaction_open
+          unless transaction_args[:require_new]
+            transaction_args[:require_new] = true
+            logger.warn("[#{self}.transaction_wrapper] Opening a nested transaction. Setting require_new: true")
+          else
+            logger.debug("[#{self}.transaction_wrapper] Will start a nested transaction.")
+          end
+          run_inside_transaction_block(transaction_args: transaction_args, inside_args: inside_args, lock: lock, transaction_open: transaction_open, object: object) do
+            yield
+          end
+        else
+          puts "what 1 #{__method__}, transaction_open: #{transaction_open}"
+          error_handler_outside_transaction(object: object, transaction_open: transaction_open, **outside_args) do
+            puts "what 1.2 #{__method__}, transaction_open: #{transaction_open}"
+            run_inside_transaction_block(transaction_args: transaction_args, inside_args: inside_args, lock: lock, transaction_open: transaction_open, object: object) do
+              puts "what 1.3 #{__method__}, transaction_open: #{transaction_open}"
+              yield
+            end
+          end
+        end
+      end
+
+      private
+
+      def run_inside_transaction_block(transaction_args:, inside_args:, lock:, transaction_open:, object: nil)
         if object
-          if args[:lock]
-            # Note with_lock will reload object!
+          if lock
+            # Note: with_lock will reload object!
+            # Note: with_lock does not accept arguments like transaction does.
             object.with_lock do
-              error_handler(object: object, **args) do
+              puts "what 4.a #{__method__}, transaction_open: #{transaction_open}"
+              error_handler_inside_transaction(object: object, transaction_open: transaction_open, **inside_args) do
+                puts "what 4.a.1 #{__method__}, transaction_open: #{transaction_open}"
                 yield
               end
             end
           else
-            object.transaction do
-              error_handler(object: object, **args) do
+            object.transaction(**transaction_args) do
+              puts "what 4.b #{__method__}, transaction_open: #{transaction_open}"
+              error_handler_inside_transaction(object: object, transaction_open: transaction_open, **inside_args) do
+                puts "what 4.b.1 #{__method__}, transaction_open: #{transaction_open}"
                 yield
               end
             end
           end
         else
-          raise ArgumentError, "No object to lock!" if args[:lock]
-          ActiveRecord::Base.transaction do
-            error_handler(object: object, **args) do
+          raise ArgumentError, "No object to lock!" if lock
+          ActiveRecord::Base.transaction(**transaction_args) do
+            puts "what 4.c #{__method__}, transaction_open: #{transaction_open}"
+            error_handler_inside_transaction(object: object, transaction_open: transaction_open, **inside_args) do
+              puts "what 4.c.1 #{__method__}, transaction_open: #{transaction_open}"
               yield
             end
           end
         end
       end
 
-      private
+      # returns a hash of the arguments to the ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction method
+      def extract_args(args, arg_names)
+        arg_names.each_with_object({}) do |key, hash|
+          hash[key] = args.delete(key)
+        end
+      end
 
-      def error_handler(object: nil, **args)
+      def error_handler_inside_transaction(object: nil, transaction_open:, **args)
+        puts "what 5 #{__method__}, transaction_open: #{transaction_open}"
         rescued_errors = Array(args[:rescued_errors])
         prepared_errors = Array(args[:prepared_errors])
         retriable_errors = Array(args[:retriable_errors])
         reraisable_errors = Array(args[:reraisable_errors])
-        rescued_errors.concat(DEFAULT_ERRORS_TO_HANDLE)
-        prepared_errors.concat(DEFAULT_ERRORS_WHICH_PREPARE_ERRORS_ON_SELF)
+        rescued_errors.concat(DEFAULT_ERRORS_TO_HANDLE_INSIDE_TRANSACTION)
+        prepared_errors.concat(DEFAULT_ERRORS_PREPARE_ON_SELF_INSIDE)
         already_been_added_to_self, needing_added_to_self = rescued_errors.partition {|error_class| prepared_errors.include?(error_class)}
+        local_context = INSIDE_CONTEXT
+        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self) do
+          puts "what 5.1 #{__method__}, transaction_open: #{transaction_open}"
+          yield
+        end
+      end
+
+      def error_handler_outside_transaction(object: nil, transaction_open:, **args)
+        puts "what 2.1 #{__method__}, transaction_open: #{transaction_open}"
+        rescued_errors = Array(args[:outside_rescued_errors])
+        prepared_errors = Array(args[:outside_prepared_errors])
+        retriable_errors = Array(args[:outside_retriable_errors])
+        reraisable_errors = Array(args[:outside_reraisable_errors])
+        rescued_errors.concat(DEFAULT_ERRORS_TO_HANDLE_OUTSIDE_TRANSACTION)
+        prepared_errors.concat(DEFAULT_ERRORS_PREPARE_ON_SELF_OUTSIDE)
+        already_been_added_to_self, needing_added_to_self = rescued_errors.partition {|error_class| prepared_errors.include?(error_class)}
+        local_context = OUTSIDE_CONTEXT
+        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self) do
+          puts "what 2.2 #{__method__}, transaction_open: #{transaction_open}"
+          yield
+        end
+      end
+
+      def run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self)
+        puts "what 3.1 #{__method__}: local_context: #{local_context}, transaction_open: #{transaction_open}"
         re_try = false
-        begin
+        result = begin
           # If the block we yield to here raises an error that is not caught below the `true` will not get hit.
           # If the error is rescued higher up, like where the transaction in active record
           #   rescues ActiveRecord::Rollback without re-raising, then transaction_wrapper will return nil
           # If the error is not rescued higher up the error will continue to bubble
-          yield
-          true # <= make the return value meaningful.  Meaning: transaction succeeded, no errors raised
+          # If we were already inside a transaction, such that this one is nested,
+          #   then the result of the yield is what we want to return, to preserve the innermost result
+          result = yield
+          # When in the outside context we need to preserve the inside result so it bubles up unmolested with the "meaningful" result of the transaction.
+          if transaction_open || local_context == OUTSIDE_CONTEXT
+            puts "what 3.2.a preserving: #{result.inspect}, local_context: #{local_context}, transaction_open: #{transaction_open}"
+            result # <= preserve the meaningful return value.  Meaning: transaction succeeded, no errors raised
+          else
+            puts "what 3.2.b no errors! local_context: #{local_context}, transaction_open: #{transaction_open}"
+            true # <= make the return value meaningful.  Meaning: transaction succeeded, no errors raised
+          end
         rescue *reraisable_errors => error
           # This has highest precedence because raising is the most critical functionality of a raised error to keep
           #   if that is in the intended behavior, and this way a specific child of StandardError can be reraised while
           #   the parent can still be caught and added to self.errors
           # Also adds the error to the object if there is an object.
-          transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [re-raising!]")
+          transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} re-raising!]")
+          puts "what 3.2.c reraisable local_context: #{local_context}, transaction_open: #{transaction_open}"
           raise error
         rescue *retriable_errors => error
           # This will re-run the begin block above
           # WARNING: If the same error keeps getting thrown this would infinitely recurse!
           #          To avoid the infinite recursion, we track the retry state
           if re_try
-            transaction_error_logger(object: object, error: error, additional_message: " [2nd attempt]")
+            transaction_error_logger(object: object, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} 2nd attempt]")
+            puts "what 3.2.e post-retry local_context: #{local_context}, transaction_open: #{transaction_open}"
             false # <= make the return value meaningful.  Meaning is: transaction failed after two attempts
           else
             re_try = true
             # Not adding error to base when retrying, because otherwise the added error may
             #   prevent the subsequent save from working, in a catch-22
-            transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [1st attempt]")
+            transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} 1st attempt]")
+            puts "what 3.2.d pre-retry local_context: #{local_context}, transaction_open: #{transaction_open}"
             retry
           end
         rescue *already_been_added_to_self => error
           # ActiveRecord::RecordInvalid, when done correctly, will have already added the error to object.
-          transaction_error_logger(object: nil, error: error, additional_message: nil)
+          puts "what 3.2.f already: local_context: #{local_context}, transaction_open: #{transaction_open}"
+          transaction_error_logger(object: nil, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
           false # <= make the return value meaningful.  Meaning is: transaction failed
         rescue *needing_added_to_self => error
-          transaction_error_logger(object: object, error: error, additional_message: nil)
+          puts "what 3.2.g needing: local_context: #{local_context}, transaction_open: #{transaction_open}"
+          transaction_error_logger(object: object, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
           false # <= make the return value meaningful.  Meaning is: transaction failed
         end
+        puts "what 3.3 result: #{result.inspect}"
+        result
       end
 
       def transaction_error_logger(object:, error:, add_to: :base, additional_message: nil)
@@ -106,12 +223,13 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
           #   the specific record that caused the ActiveRecord::RecordInvalid error may be out of scope
           # Ideally you would rewrite the caller to call transaction_wrapper on a single record (even if updates happen on other records)
           logger.error("[#{self}.transaction_wrapper] #{error.class}: #{error.message}#{additional_message}")
+          puts("[#{self}.transaction_wrapper] #{error.class}: #{error.message}#{additional_message}")
         else
           logger.error("[#{self}.transaction_wrapper] On #{object.class} #{error.class}: #{error.message}#{additional_message}")
+          puts("[#{self}.transaction_wrapper] On #{object.class} #{error.class}: #{error.message}#{additional_message}")
           object.errors.add(add_to, error.message) unless add_to.nil?
         end
       end
     end
-
   end
 end

data/lib/activerecord/transactionable/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Transactionable
-    VERSION = "0.1.3"
+    VERSION = "1.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-transactionable
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-10 00:00:00.000000000 Z
+date: 2017-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel