counter_culture 0.1.3

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@counter_culture

data/Gemfile

@@ -0,0 +1,22 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development, :test do
+  gem "rails"
+  gem "rspec", "~> 2.10.0"
+  gem "after_commit_action"
+end
+
+group :development do
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.2.0.pre"
+  gem "jeweler", "~> 1.8.3"
+end
+
+group :test do
+  gem "sqlite3"
+end

data/Gemfile.lock

@@ -0,0 +1,109 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.3)
+      actionpack (= 3.2.3)
+      mail (~> 2.4.4)
+    actionpack (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+    activerecord (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    after_commit_action (0.1.3)
+      activerecord (>= 3.0.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.0)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.3)
+    json (1.7.3)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    multi_json (1.3.5)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.3)
+      actionmailer (= 3.2.3)
+      actionpack (= 3.2.3)
+      activerecord (= 3.2.3)
+      activeresource (= 3.2.3)
+      activesupport (= 3.2.3)
+      bundler (~> 1.0)
+      railties (= 3.2.3)
+    railties (3.2.3)
+      actionpack (= 3.2.3)
+      activesupport (= 3.2.3)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.6)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  after_commit_action
+  bundler (~> 1.2.0.pre)
+  jeweler (~> 1.8.3)
+  rails
+  rdoc (~> 3.12)
+  rspec (~> 2.10.0)
+  sqlite3

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Magnus von Koeller
+
+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.md

@@ -0,0 +1,22 @@
+# counter_culture
+
+Turbo-charged counter caches for your Rails app. Huge improvements over the Rails standard counter caches:
+
+* Updates counter cache when values change, not just when creating and destroying 
+* Supports counter caches through multiple levels of relations
+* Supports dynamic column names, making it possible to split up the counter cache for different types of objects
+* Executes counter updates after the commit, avoiding [deadlocks](http://mina.naguib.ca/blog/2010/11/22/postgresql-foreign-key-deadlocks.html)
+
+## Contributing to counter_culture
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 BestVendor. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "counter_culture"
+  gem.homepage = "http://github.com/bestvendor/counter_culture"
+  gem.license = "MIT"
+  gem.summary = %Q{Turbo-charged counter caches for your Rails app.}
+  gem.description = %Q{counter_culture provides turbo-charged counter caches that are kept up-to-date not just on create and destroy, that support multiple levels of indirection through relationships, allow dynamic column names and that avoid deadlocks by updating in the after_commit callback.}
+  gem.email = "magnus@vonkoeller.de"
+  gem.authors = ["Magnus von Koeller"]
+
+  gem.add_dependency 'after_commit_action', '~> 0.1.3' 
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "counter_culture #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.3

data/counter_culture.gemspec

@@ -0,0 +1,124 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "counter_culture"
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Magnus von Koeller"]
+  s.date = "2012-05-30"
+  s.description = "counter_culture provides turbo-charged counter caches that are kept up-to-date not just on create and destroy, that support multiple levels of indirection through relationships, allow dynamic column names and that avoid deadlocks by updating in the after_commit callback."
+  s.email = "magnus@vonkoeller.de"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "counter_culture.gemspec",
+    "lib/counter_culture.rb",
+    "spec/counter_culture_spec.rb",
+    "spec/models/company.rb",
+    "spec/models/industry.rb",
+    "spec/models/product.rb",
+    "spec/models/review.rb",
+    "spec/models/user.rb",
+    "spec/rails_app/.gitignore",
+    "spec/rails_app/Gemfile",
+    "spec/rails_app/README.rdoc",
+    "spec/rails_app/Rakefile",
+    "spec/rails_app/app/assets/images/rails.png",
+    "spec/rails_app/app/assets/javascripts/application.js",
+    "spec/rails_app/app/assets/stylesheets/application.css",
+    "spec/rails_app/app/controllers/application_controller.rb",
+    "spec/rails_app/app/helpers/application_helper.rb",
+    "spec/rails_app/app/mailers/.gitkeep",
+    "spec/rails_app/app/models/.gitkeep",
+    "spec/rails_app/app/views/layouts/application.html.erb",
+    "spec/rails_app/config.ru",
+    "spec/rails_app/config/application.rb",
+    "spec/rails_app/config/boot.rb",
+    "spec/rails_app/config/database.yml",
+    "spec/rails_app/config/environment.rb",
+    "spec/rails_app/config/environments/development.rb",
+    "spec/rails_app/config/environments/production.rb",
+    "spec/rails_app/config/environments/test.rb",
+    "spec/rails_app/config/initializers/backtrace_silencers.rb",
+    "spec/rails_app/config/initializers/inflections.rb",
+    "spec/rails_app/config/initializers/mime_types.rb",
+    "spec/rails_app/config/initializers/secret_token.rb",
+    "spec/rails_app/config/initializers/session_store.rb",
+    "spec/rails_app/config/initializers/wrap_parameters.rb",
+    "spec/rails_app/config/locales/en.yml",
+    "spec/rails_app/config/routes.rb",
+    "spec/rails_app/db/seeds.rb",
+    "spec/rails_app/lib/assets/.gitkeep",
+    "spec/rails_app/lib/tasks/.gitkeep",
+    "spec/rails_app/log/.gitkeep",
+    "spec/rails_app/public/404.html",
+    "spec/rails_app/public/422.html",
+    "spec/rails_app/public/500.html",
+    "spec/rails_app/public/favicon.ico",
+    "spec/rails_app/public/index.html",
+    "spec/rails_app/public/robots.txt",
+    "spec/rails_app/script/rails",
+    "spec/rails_app/test/fixtures/.gitkeep",
+    "spec/rails_app/test/functional/.gitkeep",
+    "spec/rails_app/test/integration/.gitkeep",
+    "spec/rails_app/test/performance/browsing_test.rb",
+    "spec/rails_app/test/test_helper.rb",
+    "spec/rails_app/test/unit/.gitkeep",
+    "spec/rails_app/vendor/assets/javascripts/.gitkeep",
+    "spec/rails_app/vendor/assets/stylesheets/.gitkeep",
+    "spec/rails_app/vendor/plugins/.gitkeep",
+    "spec/schema.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/bestvendor/counter_culture"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.21"
+  s.summary = "Turbo-charged counter caches for your Rails app."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rails>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.10.0"])
+      s.add_development_dependency(%q<after_commit_action>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.2.0.pre"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_runtime_dependency(%q<after_commit_action>, ["~> 0.1.3"])
+    else
+      s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.10.0"])
+      s.add_dependency(%q<after_commit_action>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.2.0.pre"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<after_commit_action>, ["~> 0.1.3"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.10.0"])
+    s.add_dependency(%q<after_commit_action>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.2.0.pre"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<after_commit_action>, ["~> 0.1.3"])
+  end
+end
+

data/lib/counter_culture.rb

@@ -0,0 +1,260 @@
+require 'after_commit_action'
+
+module CounterCulture
+
+  module ActiveRecord
+
+    def self.included(base)
+      # also add class methods to ActiveRecord::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # this holds all configuration data
+      attr_reader :after_commit_counter_cache
+
+      # called to configure counter caches
+      def counter_culture(relation, options = {})
+        unless @after_commit_counter_cache
+          # initialize callbacks only once
+          after_create :_update_counts_after_create
+          after_destroy :_update_counts_after_destroy
+          after_update :_update_counts_after_update
+
+          # we keep a list of all counter caches we must maintain
+          @after_commit_counter_cache = []
+        end
+
+        # add the current information to our list
+        @after_commit_counter_cache<< {
+          :relation => relation.is_a?(Enumerable) ? relation : [relation],
+          :counter_cache_name => (options[:column_name] || "#{name.tableize}_count"),
+          :column_names => options[:column_names],
+          :foreign_key_values => options[:foreign_key_values]
+        }
+      end
+
+      # checks all of the declared counter caches on this class for correctnes based
+      # on original data; if the counter cache is incorrect, sets it to the correct
+      # count
+      #
+      # returns: a list of fixed record as an array of hashes of the form:
+      #   { :entity => which model the count was fixed on,
+      #     :id => the id of the model that had the incorrect count,
+      #     :what => which column contained the incorrect count,
+      #     :wrong => the previously saved, incorrect count,
+      #     :right => the newly fixed, correct count }
+      #
+      def counter_culture_fix_counts
+        fixed = []
+        @after_commit_counter_cache.map do |hash|
+          # which class does this relation ultimately point to? that's where we have to start
+          klass = relation_klass(hash[:relation])
+
+          # we are only interested in the id and the count of related objects (that's this class itself)
+          query = klass.select("#{klass.table_name}.id, COUNT(#{self.table_name}.id) AS count")
+          query = query.group("#{klass.table_name}.id")
+
+          # if we're provided a custom set of column names with conditions, use them; just use the
+          # column name otherwise
+          raise "Must provide :column_names option for relation #{hash[:relation].inspect} when :counter_cache_name is a Proc" if hash[:counter_cache_name].is_a?(Proc) && !hash[:column_names]
+          column_names = hash[:column_names] || {nil => hash[:counter_cache_name]}
+          raise ":column_names must be a Hash of conditions and column names" unless column_names.is_a?(Hash)
+
+          # iterate over all the possible counter cache column names
+          column_names.each do |where, column_name|
+            # if there are additional conditions, add them here
+            counts = query.where(where)
+
+            # we need to work our way back from the end-point of the relation to this class itself;
+            # make a list of arrays pointing to the second-to-last, third-to-last, etc.
+            reverse_relation = []
+            (1..hash[:relation].length).to_a.reverse.each {|i| reverse_relation<< hash[:relation][0,i] }
+
+            # we need to join together tables until we get back to the table this class itself
+            # lives in
+            reverse_relation.each do |cur_relation|
+              reflect = relation_reflect(cur_relation)
+              counts = counts.joins("JOIN #{reflect.active_record.table_name} ON #{reflect.table_name}.id = #{reflect.active_record.table_name}.#{reflect.foreign_key}")
+            end
+            # and then we collect the counts in an id => count hash
+            counts = counts.inject({}){|memo, model| memo[model.id] = model.count.to_i; memo}
+
+            # now that we know what the correct counts are, we need to iterate over all instances
+            # and check whether the count is correct; if not, we correct it
+            klass.find_each do |model|
+              if model.send(column_name) != counts[model.id].to_i
+                # keep track of what we fixed, e.g. for a notification email
+                fixed<< {
+                  :entity => klass.name,
+                  :id => model.id,
+                  :what => column_name,
+                  :wrong => model.send(column_name),
+                  :right => counts[model.id]
+                }
+                # use update_all because it's faster and because a fixed counter-cache shouldn't
+                # update the timestamp
+                klass.update_all "#{column_name} = #{counts[model.id].to_i}", "id = #{model.id}"
+              end
+            end
+          end
+        end
+
+        return fixed
+      end
+
+      private
+      # gets the reflect object on the given relation
+      #
+      # relation: a symbol or array of symbols; specifies the relation
+      #   that has the counter cache column
+      def relation_reflect(relation)
+        relation = relation.is_a?(Enumerable) ? relation.dup : [relation]
+
+        # go from one relation to the next until we hit the last reflect object
+        klass = self
+        while relation.size > 0
+          cur_relation = relation.shift
+          reflect = klass.reflect_on_association(cur_relation)
+          raise "No relation #{cur_relation} on #{klass.name}" if reflect.nil?
+          klass = reflect.klass
+        end
+
+        return reflect
+      end
+
+      # gets the class of the given relation
+      #
+      # relation: a symbol or array of symbols; specifies the relation
+      #   that has the counter cache column
+      def relation_klass(relation)
+        relation_reflect(relation).klass
+      end
+
+      # gets the foreign key name of the given relation
+      #
+      # relation: a symbol or array of symbols; specifies the relation
+      #   that has the counter cache column
+      def relation_foreign_key(relation)
+        relation_reflect(relation).foreign_key
+      end
+      
+      # gets the foreign key name of the relation. will look at the first
+      # level only -- i.e., if passed an array will consider only its
+      # first element
+      #
+      # relation: a symbol or array of symbols; specifies the relation
+      #   that has the counter cache column
+      def first_level_relation_foreign_key(relation)
+        relation = relation.first if relation.is_a?(Enumerable)
+        relation_reflect(relation).foreign_key
+      end
+        
+    end
+
+    private
+    # called by after_create callback
+    def _update_counts_after_create
+      self.class.after_commit_counter_cache.each do |hash|
+        # increment counter cache
+        change_counter_cache(true, hash)
+      end
+    end
+
+    # called by after_destroy callback
+    def _update_counts_after_destroy
+      self.class.after_commit_counter_cache.each do |hash|
+        # decrement counter cache
+        change_counter_cache(false, hash)
+      end
+    end
+
+    # called by after_update callback
+    def _update_counts_after_update
+      self.class.after_commit_counter_cache.each do |hash|
+        # only update counter caches if the foreign key changed
+        if send("#{first_level_relation_foreign_key(hash[:relation])}_changed?")
+          # increment the counter cache of the new value
+          change_counter_cache(true, hash)
+          # decrement the counter cache of the old value
+          change_counter_cache(false, hash, true)
+        end
+      end
+    end
+
+    # increments or decrements a counter cache
+    #
+    # increment: true to increment, false to decrement
+    # hash:
+    #   :relation => which relation to increment the count on, 
+    #   :counter_cache_name => the column name of the counter cache
+    # was: whether to get the current value or the old value of the
+    #   first part of the relation
+    def change_counter_cache(increment, hash, was = false)
+      # default to the current foreign key value
+      id_to_change = foreign_key_value(hash[:relation], was)
+      # allow overwriting of foreign key value by the caller
+      id_to_change = hash[:foreign_key_values].call(id_to_change) if hash[:foreign_key_values]
+      if id_to_change
+        execute_after_commit do
+          # increment or decrement?
+          method = increment ? :increment_counter : :decrement_counter
+
+          # figure out what the column name is
+          if hash[:counter_cache_name].is_a? Proc
+            # dynamic column name -- call the Proc
+            counter_cache_name = hash[:counter_cache_name].call(self) 
+          else
+            # static column name
+            counter_cache_name = hash[:counter_cache_name]
+          end
+
+          # do it!
+          relation_klass(hash[:relation]).send(method, counter_cache_name, id_to_change)
+        end
+      end
+    end
+
+    # gets the value of the foreign key on the given relation
+    #
+    # relation: a symbol or array of symbols; specifies the relation
+    #   that has the counter cache column
+    # was: whether to get the current or past value from ActiveRecord;
+    #   pass true to get the past value, false or nothing to get the
+    #   current value
+    def foreign_key_value(relation, was = false)
+      relation = relation.is_a?(Enumerable) ? relation.dup : [relation]
+      if was
+        first = relation.shift
+        foreign_key_value = send("#{relation_foreign_key(first)}_was")
+        value = relation_klass(first).find(foreign_key_value) if foreign_key_value
+      else
+        value = self
+      end
+      while !value.nil? && relation.size > 0
+        value = value.send(relation.shift)
+      end
+      return value.try(:id)
+    end
+
+    def relation_klass(relation)
+      self.class.send :relation_klass, relation
+    end
+
+    def relation_reflect(relation)
+      self.class.send :relation_reflect, relation
+    end
+    
+    def relation_foreign_key(relation)
+      self.class.send :relation_foreign_key, relation
+    end
+
+    def first_level_relation_foreign_key(relation)
+      self.class.send :first_level_relation_foreign_key, relation
+    end
+
+  end
+
+  # extend ActiveRecord with our own code here
+  ::ActiveRecord::Base.send :include, ActiveRecord
+end