ar-async-counter-cache 0.0.1 → 0.0.2

data/README

@@ -0,0 +1,68 @@
+ar-async-counter-cache
+----------------------
+
+This gem allows you to update ActiveRecord counter cache columns
+asynchronously. You may want to do this in situations where you want really
+speedy inserts and have models that "belong_to" many different parents.
+
+You use it like such:
+
+    class User < ActiveRecord::Base
+      has_many :comments
+      has_many :posts
+    end
+    
+    class Post < ActiveRecord::Base
+      belongs_to :user, :async_counter_cache => true
+      has_many :comments
+    end
+    
+    class Comment < ActiveRecord::Base
+      belongs_to :user, :async_counter_cache => true
+      belongs_to :post, :async_counter_cache => "count_of_comments"
+    end
+
+Notice, you may specify the name of the counter cache column just as you can
+with the normal belongs_to :counter_cache option. You also may not use both
+the :async_counter_cache and :counter_cache options in the same belongs_to
+call.
+
+All you should need to do is require this gem in your project that uses
+ActiveRecord and you should be good to go;
+
+  e.g. In your Gemfile:
+
+    gem 'ar-async-counter-cache', '0.0.1'
+
+  and then in RAILS_ROOT/config/environment.rb somewhere:
+    
+    require 'ar-async-counter-cache'
+
+This gem has built-in support for Resque (http://github.com/defunkt/resque).
+Al you need is resque in your loadpath:
+
+  e.g. In your Gemfile:
+
+    gem 'resque', '1.9.4'
+
+By default, the Resque job is placed on the :default queue:
+
+    @queue = :default
+
+However, you can change this:
+
+  in RAILS_ROOT/config/environment.rb somewhere:
+
+    ArAsyncCounterCache.resque_job_queue = :low_priority
+
+If you don't want to use Resque, you must define one instance method for your
+models using ar-async-counter-cache:
+
+  e.g.:
+
+    Comment#async_increment_counters
+
+That method should pass a message onto a queue for a background processor to
+handle later. That background processor should call:
+
+    Comment#update_async_counters(:increment)

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/ar-async-counter-cache.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ar-async-counter-cache}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Gibralter"]
@@ -22,7 +22,8 @@ Gem::Specification.new do |s|
      "ar-async-counter-cache.gemspec",
      "lib/ar-async-counter-cache.rb",
      "lib/ar_async_counter_cache/active_record.rb",
-     "lib/ar_async_counter_cache/resque_job.rb",
+     "lib/ar_async_counter_cache/increment_counters_job.rb",
+     "pkg/ar-async-counter-cache-0.0.1.gem",
      "spec/ar_async_counter_cache/active_record_spec.rb",
      "spec/integration_spec.rb",
      "spec/models.rb",
@@ -32,7 +33,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/agibralter/ar-async-counter-cache}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Increment ActiveRecord's counter cache column asynchronously (using Resque).}
   s.test_files = [
     "spec/ar_async_counter_cache/active_record_spec.rb",
@@ -45,7 +46,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activerecord>, [">= 2.3.5"])
     else
       s.add_dependency(%q<activerecord>, [">= 2.3.5"])

data/lib/ar-async-counter-cache.rb

@@ -1,10 +1,11 @@
+require 'active_record'
+
 begin
   require 'resque'
-  require 'ar_async_counter_cache/resque_job'
+  require 'ar_async_counter_cache/increment_counters_job'
 rescue LoadError
 end
 
-require 'active_record'
 require 'ar_async_counter_cache/active_record'
 
 ActiveRecord::Base.send(:include, ArAsyncCounterCache::ActiveRecord)

data/lib/ar_async_counter_cache/active_record.rb

@@ -9,13 +9,6 @@ module ArAsyncCounterCache
       }.gsub(/\s+/, ' ').strip
     end
 
-    def async_decrement_counters
-      raise %{
-        Since you don't have resque installed, please define #{self.class.to_s}#async_decrement_counters.
-        Basically it should queue a job that calls #{self.class.to_s}#update_async_counters(:decrement).
-      }.gsub(/\s+/, ' ').strip
-    end
-
     def update_async_counters(dir, *parent_types)
       (parent_types.empty? ? self.class.async_counter_types.keys : parent_types).each do |parent_type|
         if (col = self.class.async_counter_types[parent_type]) && (parent = send(parent_type))
@@ -53,9 +46,9 @@ module ArAsyncCounterCache
       def add_callbacks
         # Define after_create callback method.
         method_name = "belongs_to_async_counter_cache_after_create".to_sym
-        if defined?(ArAsyncCounterCache::UpdateCountersJob)
+        if defined?(ArAsyncCounterCache::IncrementCountersJob)
           define_method(method_name) do
-            Resque.enqueue(ArAsyncCounterCache::UpdateCountersJob, self.class.to_s, self.id, :increment)
+            Resque.enqueue(ArAsyncCounterCache::IncrementCountersJob, self.class.to_s, self.id)
           end
         else
           define_method(method_name) do
@@ -65,14 +58,8 @@ module ArAsyncCounterCache
         after_create(method_name)
         # Define before_destroy callback method.
         method_name = "belongs_to_async_counter_cache_before_destroy".to_sym
-        if defined?(ArAsyncCounterCache::UpdateCountersJob)
-          define_method(method_name) do
-            Resque.enqueue(ArAsyncCounterCache::UpdateCountersJob, self.class.to_s, self.id, :decrement)
-          end
-        else
-          define_method(method_name) do
-            self.async_decrement_counters
-          end
+        define_method(method_name) do
+          update_async_counters(:decrement)
         end
         before_destroy(method_name)
       end

data/lib/ar_async_counter_cache/{resque_job.rb → increment_counters_job.rb}

@@ -1,25 +1,26 @@
 module ArAsyncCounterCache
 
   def self.resque_job_queue=(sym)
-    ArAsyncCounterCache::UpdateCountersJob.class_eval do
+    ArAsyncCounterCache::IncrementCountersJob.class_eval do
       @queue = sym
     end
   end
 
-  class UpdateCountersJob
+  class IncrementCountersJob
     @queue = :default
 
     # Take advantage of resque-retry if possible.
     begin
       require 'resque-retry'
+      require 'active_record/base'
       extend Resque::Plugins::ExponentialBackoff
-      @retry_exceptions = [ActiveRecord::RecordNotFound]
+      @retry_exceptions = [::ActiveRecord::RecordNotFound]
       @backoff_strategy = [0, 10, 100]
     rescue LoadError
     end
 
-    def self.perform(klass_name, id, dir)
-      Object.const_get(klass_name).find(id).update_async_counters(dir)
+    def self.perform(klass_name, id)
+      Object.const_get(klass_name).find(id).update_async_counters(:increment)
     end
   end
 end

data/spec/ar_async_counter_cache/active_record_spec.rb

@@ -16,7 +16,7 @@ describe ArAsyncCounterCache::ActiveRecord do
     end
     
     it "should queue job" do
-      Resque.should_receive(:enqueue).with(ArAsyncCounterCache::UpdateCountersJob, "Post", an_instance_of(Fixnum), :increment)
+      Resque.should_receive(:enqueue).with(ArAsyncCounterCache::IncrementCountersJob, "Post", an_instance_of(Fixnum))
       @user.posts.create(:body => "I have a cat!")
     end
   end

data/spec/integration_spec.rb

@@ -44,11 +44,11 @@ describe "integration" do
     @post2.reload.count_of_comments.should == 1
   end
 
-  it "should decrement too" do
+  it "should decrement synchronously" do
+    perform_all_jobs
     @comment1.destroy
     @comment2.destroy
     @comment3.destroy
-    perform_all_jobs
     @user1.reload.posts_count.should == 2
     @user1.reload.comments_count.should == 0
     @user2.reload.posts_count.should == 0

data/spec/spec_helper.rb

@@ -1,13 +1,10 @@
 spec_dir = File.expand_path(File.dirname(__FILE__))
-
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-$: << spec_dir
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
 
 require 'rubygems'
 # Ensure resque for tests.
 require 'resque'
 require 'ar-async-counter-cache'
-
 require 'spec'
 require 'models'
 

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: ar-async-counter-cache
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Aaron Gibralter
@@ -22,11 +21,9 @@ dependencies:
   name: activerecord
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 9
         segments: 
         - 2
         - 3
@@ -49,7 +46,8 @@ files:
 - ar-async-counter-cache.gemspec
 - lib/ar-async-counter-cache.rb
 - lib/ar_async_counter_cache/active_record.rb
-- lib/ar_async_counter_cache/resque_job.rb
+- lib/ar_async_counter_cache/increment_counters_job.rb
+- pkg/ar-async-counter-cache-0.0.1.gem
 - spec/ar_async_counter_cache/active_record_spec.rb
 - spec/integration_spec.rb
 - spec/models.rb
@@ -65,27 +63,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Increment ActiveRecord's counter cache column asynchronously (using Resque).