fish_transactions 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a822130f177c9753a9d30a248208ae38d46e29c7
+  data.tar.gz: 051ec846fc08b2a295d8f88601c4da608c73f7f0
+SHA512:
+  metadata.gz: 5c9a9eb96340b83db54f2f20679616af083b25bd02892c6aceb5438de74c2a5318c3741ba26ea81679d8c5e5d02dd5cc453949d6f1779073382e6f20145d1ec6
+  data.tar.gz: d7a17433321b20d4ccea1320b5c956efe518e514c5e0c814867fbcd8040ce110697692901f66f7433830b698581235c78fcada6815876fc80bbc63b1eb09d4fc

data/MIT-LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 John Owen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# FishTransactions
+
+Fish Transactions allows to add transaction callbacks anywhere.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fish_transactions'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fish_transactions
+
+## Usage
+
+First you need to include `FishTransactions#Callbacks` module into the class
+you want to use it.
+Once included, you can directly call `after_commit` or `after_rollback` with
+the code you wanna run on such events.
+
+
+#### Example
+
+```ruby
+class SomeClass
+
+  include FishTransaction::Callbacks
+
+  # ...
+
+  def some_method
+    # ...
+
+    ActiveRecord::Base.transaction do
+      # executes some code
+      puts "runs within transaction"
+
+      after_commit do
+
+        # things to do after transaction
+        puts "runs after transaction"
+
+      end
+
+      # executes more code
+      puts "again runs within transaction"
+    end
+    # ...
+
+  end
+
+  # ...
+
+end
+
+```
+will output
+```
+runs within transaction
+again runs within transaction
+runs after transaction
+```
+
+Please see [FishTransactions::Callbacks](FishTransactions/Callbacks.html) for more details.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+[beetrack/fish_transactions](https://github.com/beetrack/fish_transactions). This project is intended to be
+a safe, welcoming space for collaboration, and contributors are expected to
+adhere to the [Contributor Covenant](http://contributor-covenant.org) code
+of conduct.
+
+
+## Development
+
+This gem is inspired on [AR After Transaction gem](https://github.com/grosser/ar_after_transaction).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require 'rdoc/task'
+task :default => :spec
+
+desc 'Generate documentation for FishTransactions.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'Fish Transactions'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.main = 'README.md'
+end

data/lib/fish_transactions/active_record_mods/base.rb

@@ -0,0 +1,67 @@
+require 'fish_transactions/callbacks_storage'
+
+module FishTransactions
+
+  ##
+  # Module that modifies ActiveRecord transactions to capture events
+  module ActiveRecordMods
+    ##
+    # Modifications for ActiveRecord::Base class
+    # All methods here will be class level methods
+    module Base
+
+      ##
+      # When extended, this module will:
+      #
+      # * alias the +:transaction+ method and them override it
+      def self.extended( base )
+
+        base.class_eval do
+          class << self
+            # create an alias for the original +transaction+ method
+            alias_method :original_ar_transaction, :transaction
+            # and we 'rename' the new method as transaction
+            alias_method :transaction, :transaction_with_callbacks
+          end
+        end
+
+      end
+
+
+
+      ##
+      # Wrapper of original transaction.
+      # Captures and then raises Rollback exception
+      # to know there were a rollback
+      def transaction_with_callbacks(*args)
+
+        committed = true
+
+        original_ar_transaction(*args) do
+          begin
+            yield
+          rescue ActiveRecord::Rollback
+            committed = false
+            raise
+          end
+        end
+      rescue Exception
+        committed = false
+        raise
+      ensure
+        if committed
+          callbacks.committed!
+        else
+          callbacks.rolledback!
+        end
+      end
+
+      ##
+      # read-access to callbacks storage
+      def callbacks
+        connection.fish_callbacks_storage ||= FishTransactions::CallbacksStorage.new
+      end
+
+    end
+  end
+end

data/lib/fish_transactions/active_record_mods/connection_abstract_adapter.rb

@@ -0,0 +1,20 @@
+module FishTransactions
+
+  # :nodoc:
+  module ActiveRecordMods
+    
+    ##
+    # Modifications for ActiveRecord::ConnectionAdapters::AbstractAdapter class
+    module ConnectionAbstractAdapter
+
+      ##
+      # When included this module, will add:
+      #
+      # * <tt>attr_accessor fish_callbacks_storage</tt>
+      def self.included(base)
+        base.send(:attr_accessor,:fish_callbacks_storage)
+      end
+
+    end
+  end
+end

data/lib/fish_transactions/active_record_mods.rb

@@ -0,0 +1,6 @@
+require 'fish_transactions/active_record_mods/connection_abstract_adapter'
+require 'fish_transactions/active_record_mods/base'
+
+# :nodoc: all
+ActiveRecord::Base.extend FishTransactions::ActiveRecordMods::Base
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, FishTransactions::ActiveRecordMods::ConnectionAbstractAdapter)

data/lib/fish_transactions/callbacks.rb

@@ -0,0 +1,102 @@
+module FishTransactions
+
+  ##
+  # = Fish Transactions Callbacks
+  #
+  # This module allows to add transaction callbacks anywhere.
+  # You just need to include this module and you will able to
+  # use it.
+  #
+  module Callbacks
+
+    ##
+    # Allows to execute any block of code after transaction completes.
+    # If no transaction is actually open, the code runs immediately.
+    #
+    # Accepts the following options that modifies this behavior:
+    #
+    # * <tt>:only</tt> - Execute this code only on commit or only on
+    #   rollback. Accepts one of the following symbols: <tt>:commit</tt>,
+    #   <tt>:rollback</tt>.
+    # * <tt>:if_no_transaction</tt> - Specifies what to do if there is no
+    #   active transaction. Accepts one of the following symbols:
+    #   <tt>:run</tt> (default), <tt>:skip</tt> (do not run).
+    #
+    # Example of use:
+    #
+    #   ActiveRecord::Base.transaction do
+    #     # executes some code
+    #     puts "runs within transaction"
+    #     after_transaction do
+    #       # things to do after transaction
+    #       puts "runs after transaction"
+    #     end
+    #     # executes more code
+    #     puts "again runs within transaction"
+    #   end
+    #
+    # will output
+    #
+    #   runs within transaction
+    #   again runs within transaction
+    #   runs after transaction
+    #
+    #
+    #
+    def after_transaction(opts = {}, &block)
+
+      # default options
+      default_options = { only: nil, if_no_transaction: :run}
+      opts = default_options.merge(opts)
+
+      # normalize opts to string keys
+      normalized = opts.dup
+      opts.each{ |k,v| normalized[k.to_s] = v }
+      opts = normalized
+
+
+      if ActiveRecord::Base.connection.open_transactions > 0
+        callbacks = ActiveRecord::Base.callbacks
+
+        case opts['only']
+        when :commit
+          callbacks.store(:commit,&block)
+        when :rollback
+          callbacks.store(:rollback,&block)
+        else
+          # both cases
+          callbacks.store(:commit,&block)
+          callbacks.store(:rollback,&block)
+        end
+      else
+        if opts['if_no_transaction'] == :run
+          block.call
+        end
+      end
+    end
+    alias after_tx after_transaction
+
+    ##
+    # Executes some code only after current transactions does commit.
+    # If no transaction is actually open, the code runs immediately.
+    #
+    # Shortcut for <tt>after_transaction(only: :commit, if_no_transaction: :run) do ... end </tt>
+    #
+    # Please use #after_transaction for more options
+    def after_commit(&block)
+      after_transaction(only: :commit, &block)
+    end
+
+    ##
+    # Executes some code only after current transaction does rollback.
+    # If no transaction is actually open, the code does not runs.
+    #
+    # Shortcut for <tt>after_transaction(only: :rollback, if_no_transaction: :skip) do ... end </tt>
+    #
+    # Please use #after_transaction for more options
+    def after_rollback(&block)
+      after_transaction(only: :rollback, if_no_transaction: :skip, &block)
+    end
+
+  end
+end

data/lib/fish_transactions/callbacks_storage.rb

@@ -0,0 +1,58 @@
+module FishTransactions
+  ##
+  # Stores callbacks to be run on certain events
+  # (currently, commit-only or rollback-only)
+  class CallbacksStorage
+
+    ##
+    # Creates the storage empty
+    def initialize
+      @on_commit = []
+      @on_rollback = []
+    end
+
+    ##
+    # Stores a callback block to run on a event
+    #
+    # An event must be one of these symbols:
+    #
+    # * +:commit+ - run callback on commit only
+    # * +:rollback+ - run callback on rollback only
+    # * otherwise will raise an exception
+    def store(event,&callback_block)
+      case event
+      when :commit then @on_commit << callback_block
+      when :rollback then @on_rollback << callback_block
+      else raise "unknown event #{event.inspect}"
+      end
+    end
+
+    ##
+    # Runs all callbacks asociated with commit event
+    def committed!
+      @on_commit.each do |callback|
+        callback.call
+      end
+      clear
+    end
+
+    ##
+    # Runs all callbacks asociated with rollback event
+    def rolledback!
+      @on_rollback.each do |callback|
+        callback.call
+      end
+      clear
+    end
+
+    private
+
+    ##
+    # Clear callbacks
+    def clear
+      @on_commit.clear
+      @on_rollback.clear
+    end
+
+  end
+end

data/lib/fish_transactions/version.rb

@@ -0,0 +1,6 @@
+# :nodoc:
+module FishTransactions
+  ##
+  # current version
+  VERSION = "1.0.0"
+end

data/lib/fish_transactions.rb

@@ -0,0 +1,4 @@
+require 'fish_transactions/version'
+require 'fish_transactions/active_record_mods'
+require 'fish_transactions/callbacks'
+

data/spec/callbacks_spec.rb

@@ -0,0 +1,332 @@
+require 'fish_transactions'
+
+module FishTransactions
+
+  class TestCallbacksClass
+    include Callbacks
+
+    def run_with_after_commit
+      before_the_block
+
+      after_commit do
+        the_after_commit_block
+
+      end
+      after_the_block_just_before_commit
+    end
+
+    def run_with_after_rollback
+      before_the_block
+
+      after_rollback do
+        the_after_rollback_block
+
+      end
+      after_the_block_just_before_commit
+
+    end
+
+    def run_with_after_transaction_no_args
+      before_the_block
+
+      after_transaction do
+        the_after_transaction_block
+
+      end
+      after_the_block_just_before_commit
+
+    end
+
+    def run_with_after_transaction(opts)
+      before_the_block
+
+      after_transaction(opts) do
+        the_after_transaction_block
+
+      end
+      after_the_block_just_before_commit
+
+    end
+
+    def before_the_block; end
+    def after_the_block_just_before_commit; end
+
+    def the_after_commit_block; end
+    def the_after_rollback_block; end
+    def the_after_transaction_block; end
+
+  end
+
+  describe Callbacks do
+
+    let(:execution_double) do
+      double = TestCallbacksClass.new
+      allow(double).to receive(:run).and_call_original
+      double
+    end
+
+    describe '#after_commit' do
+
+      context 'without transaction' do
+
+        it 'should run in place' do
+
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :the_after_commit_block,
+            :after_the_block_just_before_commit
+          )
+
+          execution_double.run_with_after_commit
+
+        end
+      end
+
+      context 'within a transaction' do
+
+        it 'should wait transaction to commit' do
+
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :after_the_block_just_before_commit,
+            :the_after_commit_block
+          )
+
+          ActiveRecord::Base.transaction do
+            execution_double.run_with_after_commit
+          end
+
+        end
+
+        it 'should not run on rollback' do
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :after_the_block_just_before_commit
+          ).but_not(
+            :the_after_commit_block
+          )
+
+          ActiveRecord::Base.transaction do
+            execution_double.run_with_after_commit
+            raise ActiveRecord::Rollback
+          end
+        end
+
+      end
+
+    end
+
+    describe '#after_rollback' do
+
+      context 'without transaction' do
+
+        it 'should not run at all' do
+
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :after_the_block_just_before_commit
+          ).but_not(
+            :the_after_rollback_block
+          )
+
+          execution_double.run_with_after_rollback
+
+        end
+      end
+
+      context 'within a transaction' do
+
+        it 'should not run on commit' do
+
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :after_the_block_just_before_commit
+          ).but_not(
+            :the_after_rollback_block
+          )
+
+          ActiveRecord::Base.transaction do
+            execution_double.run_with_after_rollback
+          end
+
+        end
+
+        it 'should run on rollback' do
+          expect(execution_double).to receive_in_order(
+            :before_the_block,
+            :after_the_block_just_before_commit,
+            :the_after_rollback_block
+          )
+
+          ActiveRecord::Base.transaction do
+            execution_double.run_with_after_rollback
+            raise ActiveRecord::Rollback
+          end
+        end
+
+      end
+
+    end
+
+    describe '#after_transaction' do
+
+      context 'without a transaction' do
+
+        context 'by default' do
+
+          it 'should executes immediately' do
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :the_after_transaction_block,
+              :after_the_block_just_before_commit
+            )
+            execution_double.run_with_after_transaction_no_args
+          end
+        end
+
+        context 'and with a {:if_no_transaction => :run} param' do
+
+          it 'should executes inmediately' do
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :the_after_transaction_block,
+              :after_the_block_just_before_commit
+            )
+            execution_double.run_with_after_transaction(if_no_transaction: :run)
+          end
+        end
+
+        context 'and with a {:if_no_transaction => :skip} param' do
+          it 'should not execute' do
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit
+            ).but_not(
+              :the_after_transaction_block
+            )
+            execution_double.run_with_after_transaction(if_no_transaction: :skip)
+          end
+        end
+
+        context 'and with a {:if_no_transaction => :skip} param given as string' do
+          it 'should not execute' do
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit
+            ).but_not(
+              :the_after_transaction_block
+            )
+            execution_double.run_with_after_transaction('if_no_transaction' => 'skip')
+          end
+        end
+
+      end
+
+      context 'within a transaction' do
+
+        context 'by default' do
+          it 'should executes after commit' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit,
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction_no_args
+            end
+          end
+
+          it 'should executes after rollback' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit,
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction_no_args
+              raise ActiveRecord::Rollback
+            end
+          end
+
+          it 'should executes after failure' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit,
+              :the_after_transaction_block
+            )
+            begin
+              ActiveRecord::Base.transaction do
+                execution_double.run_with_after_transaction_no_args
+                raise "Some other exception"
+              end
+            rescue # doesn't matter
+            end
+          end
+        end
+
+        context 'and with a {only: :commit} param' do
+          it 'should executes after commit' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit,
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction(only: :commit)
+            end
+          end
+
+          it 'should not executes after rollback' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit
+            ).but_not(
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction(only: :commit)
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+
+        context 'and with a {only: :rollback} param' do
+          it 'should not executes after commit' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit
+            ).but_not(
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction(only: :rollback)
+            end
+          end
+
+          it 'should executes after rollback' do
+
+            expect(execution_double).to receive_in_order(
+              :before_the_block,
+              :after_the_block_just_before_commit,
+              :the_after_transaction_block
+            )
+            ActiveRecord::Base.transaction do
+              execution_double.run_with_after_transaction(only: :rollback)
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/callbacks_storage_spec.rb

@@ -0,0 +1,119 @@
+require 'fish_transactions/callbacks_storage'
+
+module FishTransactions
+
+  describe CallbacksStorage do
+
+
+    let(:null_proc){ Proc.new{} }
+    subject(:storage){ CallbacksStorage.new }
+
+    # just a warm test: to raise or not to raise error
+    describe '#store' do
+      it 'accepts commit event' do
+        # just run and hope no exception raised
+        storage.store(:commit,&null_proc)
+      end
+      it 'accepts commit event' do
+        storage.store(:rollback,&null_proc)
+      end
+      it 'does not accepts other events' do
+        # I prefer to repeat this code lot of times to be more clear than DRYer
+
+        # test tx AR events
+        expect { storage.store(:after_commit,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:after_rollback,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+
+        # and some common AR events
+        expect { storage.store(:after_validation,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:after_create,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:after_update,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:after_save,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+
+        expect { storage.store(:before_validation,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:before_save,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:before_create,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+        expect { storage.store(:before_update,&null_proc) }.to raise_error(RuntimeError, /^unknown event.+$/)
+      end
+    end
+
+    describe '#committed!' do
+
+      it 'runs a stored block' do
+        expect do |test_block|
+          storage.store :commit, &test_block
+          storage.committed!
+        end.to yield_control
+      end
+
+      it 'runs any stored block' do
+        expect do |test_block|
+          # i will store test block in the middle, to be sure
+          # that first or last are not the only called
+          storage.store :commit, &null_proc
+          storage.store :commit, &test_block
+          storage.store :commit, &null_proc
+          storage.committed!
+        end.to yield_control
+      end
+
+      it 'does not a rollback block' do
+        expect do |test_block|
+          storage.store :rollback, &test_block
+          storage.committed!
+        end.not_to yield_control
+      end
+
+      it 'clears callbacks' do
+        expect do |test_block|
+          storage.store :commit, &test_block
+          storage.committed!
+
+          storage.committed!
+        end.to yield_control.once
+      end
+
+    end
+
+    describe '#rollbacked!' do
+
+      it 'runs a stored block' do
+        expect do |test_block|
+          storage.store :rollback, &test_block
+          storage.rolledback!
+        end.to yield_control
+      end
+
+      it 'runs any stored block' do
+        expect do |test_block|
+          # i will store test block in the middle, to be sure
+          # that first or last are not the only called
+          storage.store :rollback, &null_proc
+          storage.store :rollback, &test_block
+          storage.store :rollback, &null_proc
+          storage.rolledback!
+        end.to yield_control
+      end
+
+      it 'does not a rollback block' do
+        expect do |test_block|
+          storage.store :commit, &test_block
+          storage.rolledback!
+        end.not_to yield_control
+      end
+
+      it 'clears callbacks' do
+        expect do |test_block|
+          storage.store :rollback, &test_block
+          storage.rolledback!
+
+          storage.rolledback!
+        end.to yield_control.once
+      end
+
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection :adapter => :nulldb
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :receive_in_order do |*expected_call_order|
+  match do |test_double|
+    Array.wrap(expected_call_order).each do |a_call|
+      expect(test_double).to receive(a_call).ordered
+    end
+    Array.wrap(@not_to_be_called).each do |avoid_call|
+      expect(test_double).not_to receive(avoid_call)
+    end
+    true
+  end
+
+  chain :but_not do |*expected_not_be_called|
+    @not_to_be_called = expected_not_be_called
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: fish_transactions
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- John Owen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: activerecord-nulldb-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Allows to pospose the execution of a code waiting for Active Record transactions,
+  on commit, on rollback or both.
+email:
+- john.owen@beetrack.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- lib/fish_transactions.rb
+- lib/fish_transactions/active_record_mods.rb
+- lib/fish_transactions/active_record_mods/base.rb
+- lib/fish_transactions/active_record_mods/connection_abstract_adapter.rb
+- lib/fish_transactions/callbacks.rb
+- lib/fish_transactions/callbacks_storage.rb
+- lib/fish_transactions/version.rb
+- spec/callbacks_spec.rb
+- spec/callbacks_storage_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Beetrack/fish_transactions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Callbacks for Active Record transactions that can be used anywhere.
+test_files:
+- spec/callbacks_spec.rb
+- spec/callbacks_storage_spec.rb
+- spec/spec_helper.rb