counter_culture 0.1.6 → 0.1.7

data/Gemfile

@@ -19,4 +19,5 @@ end
 
 group :test do
   gem "sqlite3"
+  gem "rspec-extra-formatters"
 end

data/Gemfile.lock

@@ -83,6 +83,7 @@ GEM
     rspec-core (2.10.1)
     rspec-expectations (2.10.0)
       diff-lcs (~> 1.1.3)
+    rspec-extra-formatters (0.4)
     rspec-mocks (2.10.1)
     sprockets (2.1.3)
       hike (~> 1.2)
@@ -106,4 +107,5 @@ DEPENDENCIES
   rails
   rdoc (~> 3.12)
   rspec (~> 2.10.0)
+  rspec-extra-formatters
   sqlite3

data/README.md

@@ -12,7 +12,7 @@ Turbo-charged counter caches for your Rails app. Huge improvements over the Rail
 Add counter_culture to your Gemfile:
 
 ```ruby
-gem 'counter_culture', '~> 0.1.4'
+gem 'counter_culture', '~> 0.1.7'
 ```
 
 Then run ```bundle update ```
@@ -95,6 +95,21 @@ end
 
 Now, the ```Category``` model will keep two up-to-date counter-caches in the ```awesome_count``` and ```sucky_count``` columns of the ```categories``` table. Products with type ```'awesome'``` will affect only the ```awesome_count```, while products with type ```'sucky'``` will affect only the ```sucky_count```. This will also work with multi-level counter caches.
 
+### Conditional counter cache
+
+```ruby
+class Product < ActiveRecord::Base
+  belongs_to :category
+  counter_culture :category, :column_name => Proc.new {|model| model.special? ? 'special_count' : nil }
+end
+
+class Category < ActiveRecord::Base
+  has_many :products
+end
+```
+
+Now, the ```Category``` model will keep the counter cache in ```special_count``` up-to-date. Only products where ```special?``` returns true will affect the special_count.
+
 ### Dynamically over-writing affected foreign keys
 
 ```ruby

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

data/circle.yml

@@ -0,0 +1,3 @@
+database:
+  override:
+    - echo "No database setup required..."

data/counter_culture.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "counter_culture"
-  s.version = "0.1.6"
+  s.version = "0.1.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Magnus von Koeller"]
-  s.date = "2012-06-07"
+  s.date = "2012-09-17"
   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 = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
+    "circle.yml",
     "counter_culture.gemspec",
     "lib/counter_culture.rb",
     "spec/counter_culture_spec.rb",
@@ -89,7 +90,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/bestvendor/counter_culture"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.21"
+  s.rubygems_version = "1.8.24"
   s.summary = "Turbo-charged counter caches for your Rails app."
 
   if s.respond_to? :specification_version then

data/lib/counter_culture.rb

@@ -174,7 +174,7 @@ module CounterCulture
     def _update_counts_after_create
       self.class.after_commit_counter_cache.each do |hash|
         # increment counter cache
-        change_counter_cache(true, hash)
+        change_counter_cache(hash.merge(:increment => true))
       end
     end
 
@@ -182,55 +182,79 @@ module CounterCulture
     def _update_counts_after_destroy
       self.class.after_commit_counter_cache.each do |hash|
         # decrement counter cache
-        change_counter_cache(false, hash)
+        change_counter_cache(hash.merge(:increment => false))
       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?")
+        # figure out whether the applicable counter cache changed (this can happen
+        # with dynamic column names)
+        counter_cache_name_was = counter_cache_name_for(previous_model, hash[:counter_cache_name])
+        counter_cache_name = counter_cache_name_for(self, hash[:counter_cache_name])
+
+        if send("#{first_level_relation_foreign_key(hash[:relation])}_changed?") || counter_cache_name != counter_cache_name_was
           # increment the counter cache of the new value
-          change_counter_cache(true, hash)
+          change_counter_cache(hash.merge(:increment => true, :counter_column => counter_cache_name))
           # decrement the counter cache of the old value
-          change_counter_cache(false, hash, true)
+          change_counter_cache(hash.merge(:increment => false, :was => true, :counter_column => counter_cache_name_was))
         end
       end
     end
 
     # increments or decrements a counter cache
     #
-    # increment: true to increment, false to decrement
-    # hash:
+    # options:
+    #   :increment => true to increment, false to decrement
     #   :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)
+    #   :counter_column => overrides :counter_cache_name
+    #   :was => whether to get the current value or the old value of the
+    #      first part of the relation
+    def change_counter_cache(options)
+      options[:counter_column] = counter_cache_name_for(self, options[:counter_cache_name]) unless options.has_key?(:counter_column)
+      
       # default to the current foreign key value
-      id_to_change = foreign_key_value(hash[:relation], was)
+      id_to_change = foreign_key_value(options[:relation], options[: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]
+      id_to_change = options[:foreign_key_values].call(id_to_change) if options[:foreign_key_values]
+
+      if id_to_change && options[:counter_column]
+        execute_after_commit do
+          # increment or decrement?
+          method = options[:increment] ? :increment_counter : :decrement_counter
+
+          # do it!
+          relation_klass(options[:relation]).send(method, options[:counter_column], id_to_change)
+        end
+      end
+    end
 
+    # Gets the name of the counter cache for a specific object
+    # 
+    # obj: object to calculate the counter cache name for
+    # cache_name_finder: object used to calculate the cache name
+    def counter_cache_name_for(obj, cache_name_finder)
       # figure out what the column name is
-      if hash[:counter_cache_name].is_a? Proc
+      if cache_name_finder.is_a? Proc
         # dynamic column name -- call the Proc
-        counter_cache_name = hash[:counter_cache_name].call(self) 
+        cache_name_finder.call(obj) 
       else
         # static column name
-        counter_cache_name = hash[:counter_cache_name]
+        cache_name_finder
       end
+    end
 
-      if id_to_change && counter_cache_name
-        execute_after_commit do
-          # increment or decrement?
-          method = increment ? :increment_counter : :decrement_counter
-
-          # do it!
-          relation_klass(hash[:relation]).send(method, counter_cache_name, id_to_change)
-        end
+    # Creates a copy of the current model with changes rolled back
+    def previous_model
+      prev = self.dup
+      
+      self.changed_attributes.each_pair do |key, value|
+        prev.send("#{key}=".to_sym, value)
       end
+      
+      prev
     end
 
     # gets the value of the foreign key on the given relation

data/spec/counter_culture_spec.rb

@@ -298,6 +298,68 @@ describe "CounterCulture" do
     user2.using_count.should == 0
     user2.tried_count.should == 0
   end
+  
+  describe "conditional counts on update" do
+    let(:product) {Product.create!}
+    let(:user) {User.create!}
+    
+    it "should increment and decrement if changing column name" do
+      user.using_count.should == 0
+      user.tried_count.should == 0
+      
+      review = Review.create :user_id => user.id, :product_id => product.id, :review_type => "using"
+      user.reload
+      
+      user.using_count.should == 1
+      user.tried_count.should == 0
+      
+      review.review_type = "tried"
+      review.save!
+      
+      user.reload
+      
+      user.using_count.should == 0
+      user.tried_count.should == 1
+    end
+    
+    it "should increment if changing from a nil column name" do
+      user.using_count.should == 0
+      user.tried_count.should == 0
+      
+      review = Review.create :user_id => user.id, :product_id => product.id, :review_type => nil
+      user.reload
+      
+      user.using_count.should == 0
+      user.tried_count.should == 0
+      
+      review.review_type = "tried"
+      review.save!
+      
+      user.reload
+      
+      user.using_count.should == 0
+      user.tried_count.should == 1
+    end
+    
+    it "should decrement if changing column name to nil" do
+      user.using_count.should == 0
+      user.tried_count.should == 0
+      
+      review = Review.create :user_id => user.id, :product_id => product.id, :review_type => "using"
+      user.reload
+      
+      user.using_count.should == 1
+      user.tried_count.should == 0
+      
+      review.review_type = nil
+      review.save!
+      
+      user.reload
+      
+      user.using_count.should == 0
+      user.tried_count.should == 0
+    end
+  end
 
   it "increments third-level counter cache on create" do
     industry = Industry.create
@@ -799,5 +861,21 @@ describe "CounterCulture" do
     user.using_count.should == 1
     user.tried_count.should == 1
   end
+  
+  describe "#previous_model" do
+    let(:user){User.create :name => "John Smith", :company_id => 1}
+    
+    it "should return a copy of the original model" do
+      user.name = "Joe Smith"
+      user.company_id = 2
+      prev = user.send(:previous_model)
+      
+      prev.name.should == "John Smith"
+      prev.company_id.should == 1
+      
+      user.name.should =="Joe Smith"
+      user.company_id.should == 2
+    end
+  end
 
 end

data/spec/models/review.rb

@@ -9,5 +9,5 @@ class Review < ActiveRecord::Base
   counter_culture [:user, :company]
   counter_culture [:user, :company, :industry]
   counter_culture [:user, :company, :industry], :column_name => 'rexiews_count'
-  counter_culture [:user, :company, :industry], :column_name => Proc.new { |model| "#{model.review_type}_count" }
+  counter_culture [:user, :company, :industry], :column_name => Proc.new { |model| model.review_type ? "#{model.review_type}_count" : nil }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-07 00:00:00.000000000 Z
+date: 2012-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -143,6 +143,7 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- circle.yml
 - counter_culture.gemspec
 - lib/counter_culture.rb
 - spec/counter_culture_spec.rb
@@ -217,7 +218,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2752242088378468016
+      hash: -255493455800926186
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -226,7 +227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Turbo-charged counter caches for your Rails app.