activerecord-transactionable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 134ddc5a2d594c0ddf785ff45ff5ec2661f0660e
-  data.tar.gz: 3fb2afbaa552fbec81c70bb7824874646efacfde
+  metadata.gz: 303aa3641ecea594ad05589a09a3e9d6a12c31ba
+  data.tar.gz: af04e048d3dbd066d5bd5fe917f49a6a421eba53
 SHA512:
-  metadata.gz: 78d23d187b037feb977342e6120d001c92699b7db37dfd4cb953bd4add4dcc91762f822c359ce841dd3725d6c6232fcfe375d4b2f99f61415a9fc9aabff9e5a7
-  data.tar.gz: 71d8ae5296a058dca0ff90c746b15320824556c6fde806abcdf3e01e3556e7b8a4b1e09e438bec82473222c3b60631525e9b67632f275317122055b872b49590
+  metadata.gz: d6314257b6007bd563dd9dbb682cd1ffa415fe42e7edb337303aa5ae04156fc4977e4f3bb368151fd29675e2a9af7364cf2ebff2d21542b80a9a89ab9795801a
+  data.tar.gz: fbb91d3c932c6739a0847018ce6a227beb61845109c8133542de71b3fe59e1dc4cae55cf0825632163a8d623e1150f8d3ea788ece283e8ba8fa15de460107c72

data/README.md

@@ -25,17 +25,64 @@ Or install it yourself as:
 
 ## Usage
 
+```
+class Car < ActiveRecord::Base
+  include Activerecord::Transactionable # Note lowercase "r" in Activerecord (different namespace than rails' module)
+
+  validates_presence_of :name
+end
+```
+
 When creating, saving, deleting within the transaction make sure to use the bang methods (`!`) in order to ensure a rollback on failure.
 
+When everything works:
 ```
 car = Car.new(name: "Fiesta")
 car.transaction_wrapper do
   car.save!
 end
+car.persisted? # => true
+```
+
+When something goes wrong:
+```
+car = Car.new(name: nil)
+car.transaction_wrapper do
+  car.save!
+end
+car.persisted? # => false
+car.errors.full_messages # => ["Name can't be blank"]
 ```
 
+These examples are too simple to be useful with transactions, but if you are working with multiple records then it will make sense.
+
 Also see the specs.
 
+If you need to lock the car as well as have a transaction (note: will reload the `car`):
+```
+car = Car.new(name: nil)
+car.transaction_wrapper(lock: true) do # uses ActiveRecord's with_lock
+  car.save!
+end
+car.persisted? # => false
+car.errors.full_messages # => ["Name can't be blank"]
+```
+
+If you need to know if the transaction succeeded:
+```
+car = Car.new(name: nil)
+result = car.transaction_wrapper(lock: true) do # uses ActiveRecord's with_lock
+           car.save!
+         end
+result # => true, false or nil
+```
+
+Meanings of `transaction_wrapper` return values:
+
+**nil** - ActiveRecord::Rollback was raised, and then caught by the transaction, and not re-raised; the transaction failed.
+**false** - An error was raised which was handled by the transaction_wrapper; the transaction failed.
+**true** - The transaction was a success.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/activerecord/transactionable.rb

@@ -2,7 +2,7 @@ require "activerecord/transactionable/version"
 require "active_model"
 require "active_record"
 
-module Activerecord
+module Activerecord # Note lowercase "r" in Activerecord (different namespace than rails' module)
   # SRP: Provides an example of correct behavior for wrapping transactions.
   # NOTE: Rails' transactions are per-database connection, not per-model, nor per-instance,
   #       see: http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html
@@ -20,6 +20,34 @@ module Activerecord
 
     module ClassMethods
       def transaction_wrapper(object: nil, **args)
+        if object
+          if args[:lock]
+            # Note with_lock will reload object!
+            object.with_lock do
+              error_handler(object: object, **args) do
+                yield
+              end
+            end
+          else
+            object.transaction do
+              error_handler(object: object, **args) do
+                yield
+              end
+            end
+          end
+        else
+          raise ArgumentError, "No object to lock!" if args[:lock]
+          ActiveRecord::Base.transaction do
+            error_handler(object: object, **args) do
+              yield
+            end
+          end
+        end
+      end
+
+      private
+
+      def error_handler(object: nil, **args)
         rescued_errors = Array(args[:rescued_errors])
         prepared_errors = Array(args[:prepared_errors])
         retriable_errors = Array(args[:retriable_errors])
@@ -29,10 +57,12 @@ module Activerecord
         already_been_added_to_self, needing_added_to_self = rescued_errors.partition {|error_class| prepared_errors.include?(error_class)}
         re_try = false
         begin
-          ActiveRecord::Base.transaction do
-            yield
-          end
-          true # <= make the return value meaningful.  Meaning is either: transaction succeeded, OR raised ActiveRecord::Rollback
+          # 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
         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

data/lib/activerecord/transactionable/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Transactionable
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-transactionable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-28 00:00:00.000000000 Z
+date: 2016-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Do ActiveRecord transactions the right way.