ar-async-counter-cache 0.0.3 → 0.1.1

data/README.md

@@ -0,0 +1,71 @@
+ar-async-counter-cache
+----------------------
+
+This gem allows you to update ActiveRecord counter cache columns
+asynchronously using Resque (http://github.com/defunkt/resque). You may want
+to do this in situations where you want really speedy inserts and have models
+that "belong_to" many different parents and also allows for fast inserts of
+many children for the same parent.
+
+For example, let's say a single Post gets 1000 comments very quickly. This
+will set a key in Redis indicating that there is a delta of +1000 for that
+Post's comments_count column. It will also queue 1000 Resque jobs. This is
+where resque-lock-timeout comes in. Only one of those jobs will be allowed to
+run at a time. Once a job acquires the lock it removes all other instances of
+that job from the queue (see IncrementCountersWorker.around_perform_lock1).
+
+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.1.0'
+
+and then in RAILS_ROOT/config/environment.rb somewhere:
+
+    require 'ar-async-counter-cache'
+
+By default, the Resque job is placed on the `:counter_caches` queue:
+
+    @queue = :counter_caches
+
+However, you can change this:
+
+in RAILS_ROOT/config/environment.rb somewhere:
+
+    ArAsyncCounterCache.resque_job_queue = :low_priority
+
+`ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue` can also be
+used to increment/decrement arbitrary counter cache columns (outside of
+belongs_to associations):
+
+    ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue(klass, id, column, direction)
+
+Where:
+
+ * `klass` is the Class of the ActiveRecord object
+ * `id` is the id of the object
+ * `column` is the counter cache column
+ * `direction` is either `:increment` or `:decrement`

data/Rakefile

@@ -2,12 +2,15 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name        = "ar-async-counter-cache"
-    gemspec.summary     = "Increment ActiveRecord's counter cache column asynchronously (using Resque)."
-    gemspec.description = "Increment ActiveRecord's counter cache column asynchronously (using Resque)."
+    gemspec.summary     = "Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout)."
+    gemspec.description = "Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout)."
     gemspec.email       = "aaron.gibralter@gmail.com"
     gemspec.homepage    = "http://github.com/agibralter/ar-async-counter-cache"
     gemspec.authors     = ["Aaron Gibralter"]
-    gemspec.add_dependency("activerecord", ">= 2.3.5")
+    gemspec.add_dependency("activerecord", "~> 2.3.5")
+    gemspec.add_dependency("resque", "~> 1.10.0")
+    gemspec.add_dependency("resque-lock-timeout", "~> 0.2.1")
+    gemspec.files.exclude("pkg")
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.1

data/ar-async-counter-cache.gemspec

@@ -5,26 +5,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ar-async-counter-cache}
-  s.version = "0.0.3"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Gibralter"]
-  s.date = %q{2010-06-17}
-  s.description = %q{Increment ActiveRecord's counter cache column asynchronously (using Resque).}
+  s.date = %q{2010-10-06}
+  s.description = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).}
   s.email = %q{aaron.gibralter@gmail.com}
   s.extra_rdoc_files = [
-    "README"
+    "README.md"
   ]
   s.files = [
     ".gitignore",
-     "README",
+     "README.md",
      "Rakefile",
      "VERSION",
      "ar-async-counter-cache.gemspec",
      "lib/ar-async-counter-cache.rb",
      "lib/ar_async_counter_cache/active_record.rb",
-     "lib/ar_async_counter_cache/increment_counters_job.rb",
-     "pkg/ar-async-counter-cache-0.0.1.gem",
+     "lib/ar_async_counter_cache/increment_counters_worker.rb",
      "spec/ar_async_counter_cache/active_record_spec.rb",
      "spec/integration_spec.rb",
      "spec/models.rb",
@@ -34,8 +33,8 @@ 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.6}
-  s.summary = %q{Increment ActiveRecord's counter cache column asynchronously (using Resque).}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).}
   s.test_files = [
     "spec/ar_async_counter_cache/active_record_spec.rb",
      "spec/integration_spec.rb",
@@ -47,13 +46,19 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 2.3.5"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 2.3.5"])
+      s.add_runtime_dependency(%q<resque>, ["~> 1.10.0"])
+      s.add_runtime_dependency(%q<resque-lock-timeout>, ["~> 0.2.1"])
     else
-      s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+      s.add_dependency(%q<activerecord>, ["~> 2.3.5"])
+      s.add_dependency(%q<resque>, ["~> 1.10.0"])
+      s.add_dependency(%q<resque-lock-timeout>, ["~> 0.2.1"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+    s.add_dependency(%q<activerecord>, ["~> 2.3.5"])
+    s.add_dependency(%q<resque>, ["~> 1.10.0"])
+    s.add_dependency(%q<resque-lock-timeout>, ["~> 0.2.1"])
   end
 end
 

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

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

data/lib/ar_async_counter_cache/active_record.rb

@@ -2,17 +2,13 @@ module ArAsyncCounterCache
 
   module ActiveRecord
 
-    def async_increment_counters
-      raise %{
-        Since you don't have resque installed, please define #{self.class.to_s}#async_increment_counters.
-        Basically it should queue a job that calls #{self.class.to_s}#update_async_counters(:increment).
-      }.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))
-          parent.class.send("#{dir}_counter", col, parent.id)
+    def update_async_counters(dir, *association_ids)
+      association_ids.each do |association_id|
+        reflection = self.class.reflect_on_association(association_id)
+        parent_class = reflection.klass
+        column = self.class.async_counter_types[association_id]
+        if parent_id = send(reflection.primary_key_name)
+          ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue(parent_class, parent_id, column, dir)
         end
       end
     end
@@ -20,21 +16,22 @@ module ArAsyncCounterCache
     module ClassMethods
 
       def belongs_to(association_id, options={})
-        if col = async_counter_cache_column(options.delete(:async_counter_cache))
-          # Add callbacks only once: update_async_counters updates all the
-          # model's belongs_to counter caches; we do this because there's no
-          # need to add excessive messages on the async queue.
-          add_callbacks if self.async_counter_types.empty?
-          # Store async counter so that update_async_counters knows which
-          # counters to update.
-          self.async_counter_types[association_id] = col
+        column = async_counter_cache_column(options.delete(:async_counter_cache))
+        raise "Please don't use both async_counter_cache and counter_cache." if column && options[:counter_cache]
+        super(association_id, options)
+        if column
+          # Store the async_counter_cache column for the update_async_counters
+          # helper method.
+          self.async_counter_types[association_id] = column
+          # Fetch the reflection.
+          reflection = self.reflect_on_association(association_id)
+          parent_class = reflection.klass
           # Let's make the column read-only like the normal belongs_to
           # counter_cache.
-          parrent_class = association_id.to_s.classify.constantize
-          parrent_class.send(:attr_readonly, col.to_sym) if defined?(parrent_class) && parrent_class.respond_to?(:attr_readonly)
-          raise "Please don't use both async_counter_cache and counter_cache." if options[:counter_cache]
+          parent_class.send(:attr_readonly, column.to_sym) if defined?(parent_class) && parent_class.respond_to?(:attr_readonly)
+          parent_id_column = reflection.primary_key_name
+          add_callbacks(parent_class.to_s, parent_id_column, column)
         end
-        super(association_id, options)
       end
 
       def async_counter_types
@@ -43,23 +40,22 @@ module ArAsyncCounterCache
 
       private
 
-      def add_callbacks
+      def add_callbacks(parent_class, parent_id_column, column)
+        base_method_name = "async_counter_cache_#{parent_class}_#{column}"
         # Define after_create callback method.
-        method_name = "belongs_to_async_counter_cache_after_create".to_sym
-        if defined?(ArAsyncCounterCache::IncrementCountersJob)
-          define_method(method_name) do
-            Resque.enqueue(ArAsyncCounterCache::IncrementCountersJob, self.class.to_s, self.id)
-          end
-        else
-          define_method(method_name) do
-            self.async_increment_counters
+        method_name = "#{base_method_name}_after_create".to_sym
+        define_method(method_name) do
+          if parent_id = send(parent_id_column)
+            ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue(parent_class, parent_id, column, :increment)
           end
         end
         after_create(method_name)
         # Define before_destroy callback method.
-        method_name = "belongs_to_async_counter_cache_before_destroy".to_sym
+        method_name = "#{base_method_name}_before_destroy".to_sym
         define_method(method_name) do
-          update_async_counters(:decrement)
+          if parent_id = send(parent_id_column)
+            ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue(parent_class, parent_id, column, :decrement)
+          end
         end
         before_destroy(method_name)
       end

data/lib/ar_async_counter_cache/increment_counters_worker.rb

@@ -0,0 +1,108 @@
+require 'resque'
+require 'resque-lock-timeout'
+
+module ArAsyncCounterCache
+
+  # The default Resque queue is :counter_caches.
+  def self.resque_job_queue=(queue)
+    IncrementCountersWorker.class_eval do
+      @queue = queue
+    end
+  end
+
+  # The default lock_timeout is 60 seconds.
+  def self.resque_lock_timeout=(lock_timeout)
+    IncrementCountersWorker.class_eval do
+      @lock_timeout = lock_timeout
+    end
+  end
+
+  # If you don't want to use Resque's Redis connection to store the temporary
+  # counter caches, you can set a different connection here.
+  def self.redis=(redis)
+    IncrementCountersWorker.class_eval do
+      @redis = redis
+    end
+  end
+
+  # ArAsyncCounterCache will very quickly increment a counter cache in Redis,
+  # which will then later be updated by a Resque job. Using
+  # require-lock-timeout, we can ensure that only one job per ___ is running
+  # at a time.
+  class IncrementCountersWorker
+
+    extend ::Resque::Plugins::LockTimeout
+    @queue = :counter_caches
+    @lock_timeout = 60
+
+    def self.cache_and_enqueue(parent_class, id, column, direction)
+      parent_class = parent_class.to_s
+      key = cache_key(parent_class, id, column)
+      if direction == :increment
+        redis.incr(key)
+      elsif direction == :decrement
+        redis.decr(key)
+      else
+        raise ArgumentError, "Must call ArAsyncCounterCache::IncrementCountersWorker with :increment or :decrement"
+      end
+      ::Resque.enqueue(self, parent_class, id, column)
+    end
+
+    def self.redis
+      @redis || ::Resque.redis
+    end
+
+    # args: (parent_class, id, column)
+    def self.identifier(*args)
+      args.join('-')
+    end
+
+    # Try again later if lock is in use.
+    def self.lock_failed(*args)
+      ::Resque.enqueue(self, *args)
+    end
+
+    # args: (parent_class, id, column)
+    def self.cache_key(*args)
+      "ar-async-counter-cache:#{identifier(*args)}"
+    end
+
+    # The name of this method ensures that it runs within around_perform_lock.
+    #
+    # We've leveraged resque-lock-timeout to ensure that only one job is
+    # running at a time. Now, this around filter essentially ensures that only
+    # one job per parent-column can sit on the queue at once. Since the
+    # cache_key entry in redis stores the most up-to-date delta for the
+    # parent's counter cache, we don't have to actually perform the
+    # Klass.update_counters for every increment/decrement. We can batch
+    # process!
+    def self.around_perform_lock1(*args)
+      # Remove all other instances of this job (with the same args) from the
+      # queue. Uses LREM (http://code.google.com/p/redis/wiki/LremCommand) which
+      # takes the form: "LREM key count value" and if count == 0 removes all
+      # instances of value from the list.
+      redis_job_value = ::Resque.encode(:class => self.to_s, :args => args)
+      ::Resque.redis.lrem("queue:#{@queue}", 0, redis_job_value)
+      yield
+    end
+
+    def self.perform(parent_class, id, column)
+      key = cache_key(parent_class, id, column)
+      if (delta = redis.getset(key, 0).to_i) != 0
+        begin
+          parent_class = ::Resque.constantize(parent_class)
+          parent_class.find(id)
+          parent_class.update_counters(id, column => delta)
+        rescue Exception => e
+          # If anything happens, set back the counter cache.
+          if delta > 0
+            redis.incrby(key, delta)
+          elsif delta < 0
+            redis.decrby(key, -delta)
+          end
+          raise e
+        end
+      end
+    end
+  end
+end

data/spec/ar_async_counter_cache/active_record_spec.rb

@@ -2,22 +2,20 @@ require 'spec_helper'
 
 describe ArAsyncCounterCache::ActiveRecord do
 
-  describe ArAsyncCounterCache::ActiveRecord::ClassMethods do
-    it "should set async_counter_types" do
-      Post.async_counter_types.should == {:user => "posts_count"}
-      Comment.async_counter_types.should == {:user => "comments_count", :post => "count_of_comments"}
-    end
-  end
-  
   context "callbacks" do
 
-    before(:each) do
-      @user = User.create(:name => "Susan")
+    subject { User.create(:name => "Susan") }
+
+    it "should increment" do
+      ArAsyncCounterCache::IncrementCountersWorker.should_receive(:cache_and_enqueue).with("User", subject.id, "posts_count", :increment)
+      subject.posts.create(:body => "I have a cat!")
     end
-    
-    it "should queue job" do
-      Resque.should_receive(:enqueue).with(ArAsyncCounterCache::IncrementCountersJob, "Post", an_instance_of(Fixnum))
-      @user.posts.create(:body => "I have a cat!")
+
+    it "should increment" do
+      ArAsyncCounterCache::IncrementCountersWorker.stub(:cache_and_enqueue)
+      post = subject.posts.create(:body => "I have a cat!")
+      ArAsyncCounterCache::IncrementCountersWorker.should_receive(:cache_and_enqueue).with("User", subject.id, "posts_count", :decrement)
+      post.destroy
     end
   end
 end

data/spec/integration_spec.rb

@@ -5,7 +5,6 @@ describe "integration" do
   before(:each) do
     @worker = Resque::Worker.new(:testing)
     @worker.register_worker
-    # Models...
     @user1 = User.create(:name => "Susan")
     @user2 = User.create(:name => "Bob")
     @post1 = @user1.posts.create(:body => "I have a cat!")
@@ -15,40 +14,82 @@ describe "integration" do
     @comment3 = @post2.comments.create(:body => "Your mouse also sucks!", :user => @user2)
   end
 
-  it "should set countercache asynchronously" do
+  it "should increment/decrement counter caches asynchronously in batches" do
+    # Should be asynchronous...
     @user1.posts_count.should == 0
     @user1.comments_count.should == 0
     @user2.posts_count.should == 0
     @user2.comments_count.should == 0
     @post1.count_of_comments.should == 0
     @post2.count_of_comments.should == 0
-  end
 
-  it "should perform one at a time" do
+    # 2 for posts incrementing users' posts counts
+    # 3 for comments incrementing users' comments counts
+    # 3 for comments incrementing posts' comments counts
+    Resque.size(:testing).should == 8
+
+    # [ArAsyncCounterCache::IncrementCountersWorker, "User", 1, "posts_count"]
     perform_next_job
-    @user1.reload.posts_count.should == 1
+    @user1.reload.posts_count.should == 2
     @user1.reload.comments_count.should == 0
     @user2.reload.posts_count.should == 0
     @user2.reload.comments_count.should == 0
     @post1.reload.count_of_comments.should == 0
     @post2.reload.count_of_comments.should == 0
-  end
 
-  it "should update all counters once the jobs are done" do
-    perform_all_jobs
+    # [ArAsyncCounterCache::IncrementCountersWorker, "User", 2, "comments_count"]
+    perform_next_job
+    @user1.reload.posts_count.should == 2
+    @user1.reload.comments_count.should == 0
+    @user2.reload.posts_count.should == 0
+    @user2.reload.comments_count.should == 2
+    @post1.reload.count_of_comments.should == 0
+    @post2.reload.count_of_comments.should == 0
+
+    # [ArAsyncCounterCache::IncrementCountersWorker, "Post", 1, "count_of_comments"]
+    perform_next_job
+    @user1.reload.posts_count.should == 2
+    @user1.reload.comments_count.should == 0
+    @user2.reload.posts_count.should == 0
+    @user2.reload.comments_count.should == 2
+    @post1.reload.count_of_comments.should == 2
+    @post2.reload.count_of_comments.should == 0
+
+    # [ArAsyncCounterCache::IncrementCountersWorker, "User", 1, "comments_count"]
+    perform_next_job
+    @user1.reload.posts_count.should == 2
+    @user1.reload.comments_count.should == 1
+    @user2.reload.posts_count.should == 0
+    @user2.reload.comments_count.should == 2
+    @post1.reload.count_of_comments.should == 2
+    @post2.reload.count_of_comments.should == 0
+
+    # [ArAsyncCounterCache::IncrementCountersWorker, "Post", 2, "count_of_comments"]
+    perform_next_job
     @user1.reload.posts_count.should == 2
     @user1.reload.comments_count.should == 1
     @user2.reload.posts_count.should == 0
     @user2.reload.comments_count.should == 2
     @post1.reload.count_of_comments.should == 2
     @post2.reload.count_of_comments.should == 1
-  end
 
-  it "should decrement synchronously" do
-    perform_all_jobs
+    # Should be done...
+    Resque.size(:testing).should == 0
+
     @comment1.destroy
     @comment2.destroy
     @comment3.destroy
+
+    # Should be asynchronous...
+    @user1.reload.posts_count.should == 2
+    @user1.reload.comments_count.should == 1
+    @user2.reload.posts_count.should == 0
+    @user2.reload.comments_count.should == 2
+    @post1.reload.count_of_comments.should == 2
+    @post2.reload.count_of_comments.should == 1
+
+    perform_all_jobs
+
     @user1.reload.posts_count.should == 2
     @user1.reload.comments_count.should == 0
     @user2.reload.posts_count.should == 0

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar-async-counter-cache
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 3
-  version: 0.0.3
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Aaron Gibralter
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-17 00:00:00 -04:00
+date: 2010-10-06 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
+        hash: 9
         segments: 
         - 2
         - 3
@@ -31,24 +34,55 @@ dependencies:
         version: 2.3.5
   type: :runtime
   version_requirements: *id001
-description: Increment ActiveRecord's counter cache column asynchronously (using Resque).
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 1
+        - 10
+        - 0
+        version: 1.10.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: resque-lock-timeout
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id003
+description: Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).
 email: aaron.gibralter@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.md
 files: 
 - .gitignore
-- README
+- README.md
 - Rakefile
 - VERSION
 - ar-async-counter-cache.gemspec
 - lib/ar-async-counter-cache.rb
 - lib/ar_async_counter_cache/active_record.rb
-- lib/ar_async_counter_cache/increment_counters_job.rb
-- pkg/ar-async-counter-cache-0.0.1.gem
+- lib/ar_async_counter_cache/increment_counters_worker.rb
 - spec/ar_async_counter_cache/active_record_spec.rb
 - spec/integration_spec.rb
 - spec/models.rb
@@ -64,26 +98,30 @@ 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.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Increment ActiveRecord's counter cache column asynchronously (using Resque).
+summary: Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).
 test_files: 
 - spec/ar_async_counter_cache/active_record_spec.rb
 - spec/integration_spec.rb

data/README

@@ -1,68 +0,0 @@
-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 :counter_caches queue:
-
-    @queue = :counter_caches
-
-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/lib/ar_async_counter_cache/increment_counters_job.rb

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