integralimpressions-after_commit 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Nick Muerdter
+
+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

@@ -0,0 +1,34 @@
+= after_commit
+
+A Ruby on Rails plugin and Ruby Gem to add after_commit callbacks to ActiveRecord. The callbacks that are provided can be used to trigger events that run only after the entire transaction is complete. This is beneficial in situations where you are doing asynchronous processing and need committed objects.
+
+The following callbacks are provided:
+  
+   * (1) after_commit
+   * (2) after_commit_on_create
+   * (3) after_commit_on_update
+   * (4) after_commit_on_destroy
+   
+The after_commit callback is run for any object that has just been committed. You can obtain finer
+callback control by using the additional <tt>after_commit_on_*</tt> callbacks.
+
+== Plugin Usage
+
+Plugin code is at http://github.com/delynn/after_commit/tree/master
+
+  script/plugin install git://github.com/delynn/after_commit.git 
+  
+== Installing the Gem
+
+If you are using Merb or another Ruby implementation and require a gem install, use the following command:
+  
+  sudo gem install #######
+  
+The gem can be added to a project by including the code:
+
+  require 'after_commit'
+  
+The thinking-sphinx gem already includes this line, so it should not be needed for use with this package.  
+  
+  
+  

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+PLUGIN =      "after_commit"
+NAME =        PLUGIN
+GEM_VERSION = "0.0.1"
+AUTHORS =      [ 'Eli Miller', 'Joost Hietbrink', 'DeLynn Barry', 'Kane Baccigalupi']
+EMAIL =       "kane@integralimpressions.com"
+HOMEPAGE =    "http://github.com/integralimpressions/after_commit"
+SUMMARY =     %q{after_commit is an ActiveRecord gem to add an after_commit callback. This can be used to trigger things only after the entire transaction is complete.}
+
+windows = (PLATFORM =~ /win32|cygwin/)
+
+SUDO = windows ? "" : "sudo"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ "LICENSE", "README" ]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHORS
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  #s.add_dependency("activerecord",  ">=1.0")
+  #s.add_dependency("activesupport", ">=1.0")
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,specs}/**/*")
+end
+
+desc "Build gemspec file"
+task :build do
+  File.open('after_commit.gemspec', 'w') { |f| f.write spec.to_ruby }
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Run :package and install resulting .gem"
+task :install => [:package] do
+  sh %{#{SUDO} gem install pkg/#{NAME}-#{GEM_VERSION} --no-rdoc --no-ri}
+end
+
+desc 'Generate documentation for the after_commit gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AfterCommit'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/after_commit.rb

@@ -0,0 +1,9 @@
+require 'after_commit/after_commit'
+require 'after_commit/active_record'
+require 'after_commit/connection_adapters'
+
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+
+Object.subclasses_of(ActiveRecord::ConnectionAdapters::AbstractAdapter).each do |klass|
+  klass.send(:include, AfterCommit::ConnectionAdapters)
+end

data/lib/after_commit/active_record.rb

@@ -0,0 +1,88 @@
+# Based on the code found in Thinking Sphinx:
+# http://ts.freelancing-gods.com/ which was based on code written by Eli Miller:
+# http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
+# with slight modification from Joost Hietbrink, and DeLynn Barry.
+# Change to gem packaging for use with Merb/AR by Kane Baccigalupi.
+
+module AfterCommit
+  module ActiveRecord
+    def self.included(base)
+      base.class_eval do
+        # The define_callbacks method was added post Rails 2.0.2 - if it
+        # doesn't exist, we define the callback manually
+        if respond_to?(:define_callbacks)
+          define_callbacks  :after_commit,
+                            :after_commit_on_create,
+                            :after_commit_on_update,
+                            :after_commit_on_destroy
+        else
+          class << self
+            # Handle after_commit callbacks - call all the registered callbacks.
+            def after_commit(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit, callbacks)
+            end
+            
+            def after_commit_on_create(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_create_callback, callbacks)
+            end
+            
+            def after_commit_on_update(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_update_callback, callbacks)
+            end
+            
+            def after_commit_on_destroy(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_destroy_callback, callbacks)
+            end
+          end
+        end
+
+        after_save    :add_committed_record
+        after_create  :add_committed_record_on_create
+        after_update  :add_committed_record_on_update
+        after_destroy :add_committed_record_on_destroy
+
+        # We need to keep track of records that have been saved or destroyed
+        # within this transaction.
+        def add_committed_record
+          AfterCommit.committed_records << self
+        end
+        
+        def add_committed_record_on_create
+          AfterCommit.committed_records_on_create << self
+        end
+        
+        def add_committed_record_on_update
+          AfterCommit.committed_records_on_update << self
+        end
+        
+        def add_committed_record_on_destroy
+          AfterCommit.committed_records << self
+          AfterCommit.committed_records_on_destroy << self
+        end
+
+        # Wraps a call to the private callback method so that the the
+        # after_commit callback can be made from the ConnectionAdapters when
+        # the commit for the transaction has finally succeeded. 
+        def after_commit_callback
+          callback(:after_commit)
+        end
+        
+        def after_commit_on_create_callback
+          callback(:after_commit_on_create)
+        end
+        
+        def after_commit_on_update_callback
+          callback(:after_commit_on_update)
+        end
+        
+        def after_commit_on_destroy_callback
+          callback(:after_commit_on_destroy)
+        end
+      end
+    end
+  end
+end

data/lib/after_commit/after_commit.rb

@@ -0,0 +1,33 @@
+module AfterCommit
+  def self.committed_records
+    @@committed_records ||= []
+  end
+
+  def self.committed_records=(committed_records)
+    @@committed_records = committed_records
+  end
+  
+  def self.committed_records_on_create
+    @@committed_records_on_create ||= []
+  end
+  
+  def self.committed_records_on_create=(committed_records)
+    @@committed_records_on_create = committed_records
+  end
+  
+  def self.committed_records_on_update
+    @@committed_records_on_update ||= []
+  end
+  
+  def self.committed_records_on_update=(committed_records)
+    @@committed_records_on_update = committed_records
+  end
+  
+  def self.committed_records_on_destroy
+    @@committed_records_on_destroy ||= []
+  end
+  
+  def self.committed_records_on_destroy=(committed_records)
+    @@committed_records_on_destroy = committed_records
+  end
+end

data/lib/after_commit/connection_adapters.rb

@@ -0,0 +1,103 @@
+module AfterCommit
+  module ConnectionAdapters
+    def self.included(base)
+      base.class_eval do
+        # The commit_db_transaction method gets called when the outermost
+        # transaction finishes and everything inside commits. We want to
+        # override it so that after this happens, any records that were saved
+        # or destroyed within this transaction now get their after_commit
+        # callback fired.
+        def commit_db_transaction_with_callback          
+          commit_db_transaction_without_callback
+          trigger_after_commit_callbacks
+          trigger_after_commit_on_create_callbacks
+          trigger_after_commit_on_update_callbacks
+          trigger_after_commit_on_destroy_callbacks
+        end 
+        alias_method_chain :commit_db_transaction, :callback
+
+        # In the event the transaction fails and rolls back, nothing inside
+        # should recieve the after_commit callback.
+        def rollback_db_transaction_with_callback
+          rollback_db_transaction_without_callback
+
+          AfterCommit.committed_records = []
+          AfterCommit.committed_records_on_create = []
+          AfterCommit.committed_records_on_update = []
+          AfterCommit.committed_records_on_destroy = []
+        end
+        alias_method_chain :rollback_db_transaction, :callback
+        
+        protected        
+          def trigger_after_commit_callbacks
+            # Trigger the after_commit callback for each of the committed
+            # records.
+            if AfterCommit.committed_records.any?
+              AfterCommit.committed_records.each do |record|
+                begin
+                  record.after_commit_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records = []
+          end
+        
+          def trigger_after_commit_on_create_callbacks
+            # Trigger the after_commit_on_create callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_create.any?
+              AfterCommit.committed_records_on_create.each do |record|
+                begin
+                  record.after_commit_on_create_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_create = []
+          end
+        
+          def trigger_after_commit_on_update_callbacks
+            # Trigger the after_commit_on_update callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_update.any?
+              AfterCommit.committed_records_on_update.each do |record|
+                begin
+                  record.after_commit_on_update_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_update = []
+          end
+        
+          def trigger_after_commit_on_destroy_callbacks
+            # Trigger the after_commit_on_destroy callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_destroy.any?
+              AfterCommit.committed_records_on_destroy.each do |record|
+                begin
+                  record.after_commit_on_destroy_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_destroy = []
+          end
+        #end protected
+      end 
+    end 
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: integralimpressions-after_commit
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eli Miller
+- Joost Hietbrink
+- DeLynn Barry
+- Kane Baccigalupi
+autorequire: after_commit
+bindir: bin
+cert_chain: []
+
+date: 2008-10-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: after_commit is an ActiveRecord gem to add an after_commit callback. This can be used to trigger things only after the entire transaction is complete.
+email: kane@integralimpressions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/after_commit
+- lib/after_commit/active_record.rb
+- lib/after_commit/after_commit.rb
+- lib/after_commit/connection_adapters.rb
+- lib/after_commit.rb
+has_rdoc: true
+homepage: http://github.com/integralimpressions/after_commit
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: after_commit is an ActiveRecord gem to add an after_commit callback. This can be used to trigger things only after the entire transaction is complete.
+test_files: []
+