ar-async-counter-cache 0.0.1

data/Rakefile

@@ -0,0 +1,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.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")
+  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-async-counter-cache.gemspec

@@ -0,0 +1,57 @@
+# 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-async-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-06-16}
+  s.description = %q{Increment ActiveRecord's counter cache column asynchronously (using Resque).}
+  s.email = %q{aaron.gibralter@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "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/resque_job.rb",
+     "spec/ar_async_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-async-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).}
+  s.test_files = [
+    "spec/ar_async_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"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+  end
+end
+

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

@@ -0,0 +1,10 @@
+begin
+  require 'resque'
+  require 'ar_async_counter_cache/resque_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

@@ -0,0 +1,89 @@
+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 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))
+          parent.class.send("#{dir}_counter", col, parent.id)
+        end
+      end
+    end
+
+    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
+          # 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]
+        end
+        super(association_id, options)
+      end
+
+      def async_counter_types
+        @async_counter_types ||= {}
+      end
+
+      private
+
+      def add_callbacks
+        # Define after_create callback method.
+        method_name = "belongs_to_async_counter_cache_after_create".to_sym
+        if defined?(ArAsyncCounterCache::UpdateCountersJob)
+          define_method(method_name) do
+            Resque.enqueue(ArAsyncCounterCache::UpdateCountersJob, self.class.to_s, self.id, :increment)
+          end
+        else
+          define_method(method_name) do
+            self.async_increment_counters
+          end
+        end
+        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
+        end
+        before_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_async_counter_cache/resque_job.rb

@@ -0,0 +1,25 @@
+module ArAsyncCounterCache
+
+  def self.resque_job_queue=(sym)
+    ArAsyncCounterCache::UpdateCountersJob.class_eval do
+      @queue = sym
+    end
+  end
+
+  class UpdateCountersJob
+    @queue = :default
+
+    # Take advantage of resque-retry if possible.
+    begin
+      require 'resque-retry'
+      extend Resque::Plugins::ExponentialBackoff
+      @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)
+    end
+  end
+end

data/spec/ar_async_counter_cache/active_record_spec.rb

@@ -0,0 +1,23 @@
+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")
+    end
+    
+    it "should queue job" do
+      Resque.should_receive(:enqueue).with(ArAsyncCounterCache::UpdateCountersJob, "Post", an_instance_of(Fixnum), :increment)
+      @user.posts.create(:body => "I have a cat!")
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+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!")
+    @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 set countercache asynchronously" do
+    @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
+    perform_next_job
+    @user1.reload.posts_count.should == 1
+    @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
+    @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 too" do
+    @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
+    @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,47 @@
+spec_dir = File.expand_path(File.dirname(__FILE__))
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$: << spec_dir
+
+require 'rubygems'
+# Ensure resque for tests.
+require 'resque'
+require 'ar-async-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,96 @@
+--- !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
+platform: ruby
+authors: 
+- Aaron Gibralter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-16 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
+description: Increment ActiveRecord's counter cache column asynchronously (using Resque).
+email: aaron.gibralter@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- 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/resque_job.rb
+- spec/ar_async_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-async-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).
+test_files: 
+- spec/ar_async_counter_cache/active_record_spec.rb
+- spec/integration_spec.rb
+- spec/models.rb
+- spec/spec_helper.rb