ar-resque-counter-cache 0.0.1

data/README.md

@@ -0,0 +1,81 @@
+ar-resque-counter-cache (formerly ar-async-counter-cache)
+---------------------------------------------------------
+
+This gem allows you to update ActiveRecord (2.3.x) 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; that is, you want the request making the
+INSERT to return before waiting for the many UPDATE...SET counter cache SQL
+queries to finish. You may also want to use this gem to avoid "Mysql::Error:
+Lock wait timeout exceeded" issues: if you have a lot of children being created
+at a time for a single parent row, MySQL can run into lock timeouts while
+waiting for parent row to update its counter cache over and over. A while ago,
+I remember
+[seeing](http://robots.thoughtbot.com/post/159805685/tuning-the-toad) that
+Thoughtbot was having a similar issue in its Hoptoad service...
+
+How does ar-resque-counter-cache address these issues? It uses Redis as a
+temporary counter cache and Resque to actually update the counter cache column
+sometime in the future. 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-resque-counter-cache', 'x.x.x'
+
+and then in RAILS_ROOT/config/environment.rb somewhere:
+
+    require 'ar-resque-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

@@ -0,0 +1,18 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = "ar-resque-counter-cache"
+    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-resque-counter-cache"
+    gemspec.authors     = ["Aaron Gibralter"]
+    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
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ar-resque-counter-cache.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ar-resque-counter-cache}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Gibralter"]
+  s.date = %q{2010-10-13}
+  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.md"
+  ]
+  s.files = [
+    "README.md",
+     "Rakefile",
+     "VERSION",
+     "ar-resque-counter-cache.gemspec",
+     "lib/ar-resque-counter-cache.rb",
+     "lib/ar_resque_counter_cache/active_record.rb",
+     "lib/ar_resque_counter_cache/increment_counters_worker.rb",
+     "spec/ar_resque_counter_cache/active_record_spec.rb",
+     "spec/integration_spec.rb",
+     "spec/models.rb",
+     "spec/redis-test.conf",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/agibralter/ar-resque-counter-cache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  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_resque_counter_cache/active_record_spec.rb",
+     "spec/integration_spec.rb",
+     "spec/models.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    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<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<resque>, ["~> 1.10.0"])
+    s.add_dependency(%q<resque-lock-timeout>, ["~> 0.2.1"])
+  end
+end
+

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

@@ -0,0 +1,5 @@
+require 'active_record'
+require 'ar_resque_counter_cache/increment_counters_worker'
+require 'ar_resque_counter_cache/active_record'
+
+ActiveRecord::Base.send(:include, ArAsyncCounterCache::ActiveRecord)

data/lib/ar_resque_counter_cache/active_record.rb

@@ -0,0 +1,72 @@
+module ArAsyncCounterCache
+
+  module ActiveRecord
+
+    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
+
+    module ClassMethods
+
+      def belongs_to(association_id, options={})
+        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.
+          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
+      end
+
+      def async_counter_types
+        @async_counter_types ||= {}
+      end
+
+      private
+
+      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 = "#{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 after_destroy callback method.
+        method_name = "#{base_method_name}_after_destroy".to_sym
+        define_method(method_name) do
+          if parent_id = send(parent_id_column)
+            ArAsyncCounterCache::IncrementCountersWorker.cache_and_enqueue(parent_class, parent_id, column, :decrement)
+          end
+        end
+        after_destroy(method_name)
+      end
+
+      def async_counter_cache_column(opt)
+        opt === true ? "#{self.table_name}_count" : opt
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/ar_resque_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-resque-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_resque_counter_cache/active_record_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ArAsyncCounterCache::ActiveRecord do
+
+  context "callbacks" do
+
+    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 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

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe "integration" do
+
+  before(:each) do
+    @worker = Resque::Worker.new(:testing)
+    @worker.register_worker
+    @user1 = User.create(:name => "Susan")
+    @user2 = User.create(:name => "Bob")
+    @post1 = @user1.posts.create(:body => "I have a cat!")
+    @post2 = @user1.posts.create(:body => "I have a mouse!")
+    @comment1 = @post1.comments.create(:body => "Your cat sucks!", :user => @user2)
+    @comment2 = @post1.comments.create(:body => "No it doesn't!", :user => @user1)
+    @comment3 = @post2.comments.create(:body => "Your mouse also sucks!", :user => @user2)
+  end
+
+  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
+
+    # 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 == 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
+
+    # [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
+
+    # 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
+    @user2.reload.comments_count.should == 0
+    @post1.reload.count_of_comments.should == 0
+    @post2.reload.count_of_comments.should == 0
+  end
+
+  def perform_next_job
+    return unless job = @worker.reserve
+    @worker.perform(job)
+    @worker.done_working
+  end
+
+  def perform_all_jobs
+    while job = @worker.reserve
+      @worker.perform(job)
+      @worker.done_working
+    end
+  end
+end

data/spec/models.rb

@@ -0,0 +1,42 @@
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(:adapter  => 'sqlite3', :database => ':memory:')
+
+class CreateModelsForTest < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string     :name
+      t.integer    :posts_count, :default => 0
+      t.integer    :comments_count, :default => 0
+    end
+    create_table :posts do |t|
+      t.string     :body
+      t.belongs_to :user
+      t.integer    :count_of_comments, :default => 0
+    end
+    create_table :comments do |t|
+      t.string     :body
+      t.belongs_to :user
+      t.belongs_to :post
+    end
+  end
+  def self.down
+    drop_table(:users)
+    drop_table(:posts)
+    drop_table(:comments)
+  end
+end
+
+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

data/spec/redis-test.conf

@@ -0,0 +1,13 @@
+daemonize yes
+pidfile ./redis-test.pid
+port 9736
+timeout 300
+save 900 1
+save 300 10
+save 60 10000
+dbfilename ./dump.rdb
+dir .
+loglevel debug
+logfile stdout
+databases 16
+glueoutputbuf yes

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+spec_dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+require 'rubygems'
+# Ensure resque for tests.
+require 'resque'
+require 'ar-resque-counter-cache'
+require 'spec'
+require 'models'
+
+cwd = Dir.getwd
+Dir.chdir(spec_dir)
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  abort ''
+end
+
+at_exit do
+  if (pid = `cat redis-test.pid`.strip) =~ /^\d+$/
+    puts "Killing test redis server with pid #{pid}..."
+    `rm -f dump.rdb`
+    `rm -f redis-test.pid`
+    Process.kill("KILL", pid.to_i)
+    Dir.chdir(cwd)
+  end
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{spec_dir}/redis-test.conf`
+Resque.redis = '127.0.0.1:9736'
+
+Spec::Runner.configure do |config|
+  config.before(:all) do
+    ArAsyncCounterCache.resque_job_queue = :testing
+  end
+  config.before(:each) do
+    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:up) }
+    Resque.redis.flushall
+  end
+  config.after(:each) do
+    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:down) }
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: ar-resque-counter-cache
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aaron Gibralter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-13 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
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+- !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.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- ar-resque-counter-cache.gemspec
+- lib/ar-resque-counter-cache.rb
+- lib/ar_resque_counter_cache/active_record.rb
+- lib/ar_resque_counter_cache/increment_counters_worker.rb
+- spec/ar_resque_counter_cache/active_record_spec.rb
+- spec/integration_spec.rb
+- spec/models.rb
+- spec/redis-test.conf
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/agibralter/ar-resque-counter-cache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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
+signing_key: 
+specification_version: 3
+summary: Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).
+test_files: 
+- spec/ar_resque_counter_cache/active_record_spec.rb
+- spec/integration_spec.rb
+- spec/models.rb
+- spec/spec_helper.rb