counter_culture 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8651d71833facf2f685c6fcbd0ae922bb55e295d
-  data.tar.gz: dab5d1dfecaa1a880171f5378de590385cf11218
+  metadata.gz: 84e93f1182982eccea8a717da0a95ebb3e4cfef8
+  data.tar.gz: 87e88e5de74ddf5c23d7df9ff3273ce3f0b17fdf
 SHA512:
-  metadata.gz: 817f09ec93f18c4a638b1db6e34ac811a73abe2b96179bc471547cce713bc8029d7131e9577f9aac152ad82993db2e922f1a2f68d3d0541de6b7e944db05ce1c
-  data.tar.gz: a7332118c2325d9124ad1053dddb6a947e2fc2e416bdb6999e7d5c36e3cb5452c8a8ba48a6ea21d0a13d364334990cf9ee2a840bfb00b7dd738683465fdb9ed4
+  metadata.gz: 0c7286393c38d78c7d59817dfe5dae1c7c05484d3f8c186f3c56b5f0dcaa8c0da3e922aad3395ea94c08cc638536633dfbdd8c3338edf9fd17927eea029ff024
+  data.tar.gz: 4872ec4223bc8a7ebdc0ca31852e0e7358121dc32f49c8302f744d451b5e32d3a17fcf972dfa8b9cd8be3c21753c2aea38cfec8b2e2fac86ae47cc5a4b1c4079

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.5.0 (March 21, 2017)
+
+New features:
+  - Support for counter caches on one-level polymorphic relationships
+
 ## 1.4.0 (March 21, 2017)
 
 Improvements:

data/README.md

@@ -295,7 +295,7 @@ Manually populating counter caches with dynamically over-written foreign keys (`
 
 #### Polymorphic associations
 
-counter_culture currently does *not* support polymorphic associations. Check [this issue](https://github.com/magnusvk/counter_culture/issues/4) for progress and alternatives.
+counter_culture now supports polymorphic associations of one level only.
 
 ## Contributing to counter_culture
 

data/VERSION

@@ -1 +1 @@
-1.4.0
+1.5.0

data/counter_culture.gemspec

@@ -2,11 +2,11 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: counter_culture 1.4.0 ruby lib
+# stub: counter_culture 1.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "counter_culture".freeze
-  s.version = "1.4.0"
+  s.version = "1.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
@@ -48,6 +48,9 @@ Gem::Specification.new do |s|
     "spec/models/has_string_id.rb",
     "spec/models/industry.rb",
     "spec/models/person.rb",
+    "spec/models/poly_employee.rb",
+    "spec/models/poly_image.rb",
+    "spec/models/poly_product.rb",
     "spec/models/post.rb",
     "spec/models/post_comment.rb",
     "spec/models/product.rb",

data/lib/counter_culture/counter.rb

@@ -62,8 +62,9 @@ module CounterCulture
             end
           end
 
-          klass = relation_klass(relation)
-          klass.where(relation_primary_key(relation) => id_to_change).update_all updates.join(', ')
+          klass = relation_klass(relation, source: obj, was: options[:was])
+          primary_key = relation_primary_key(relation, source: obj, was: options[:was])
+          klass.where(primary_key => id_to_change).update_all updates.join(', ')
         end
       end
     end
@@ -112,15 +113,19 @@ module CounterCulture
       if was
         first = relation.shift
         foreign_key_value = attribute_was(obj, relation_foreign_key(first))
-        klass = relation_klass(first)
-        value = klass.where("#{klass.table_name}.#{relation_primary_key(first)} = ?", foreign_key_value).first if foreign_key_value
+        klass = relation_klass(first, source: obj, was: was)
+        if foreign_key_value
+          value = klass.where(
+            "#{klass.table_name}.#{relation_primary_key(first, source: obj, was: was)} = ?",
+            foreign_key_value).first
+        end
       else
         value = obj
       end
       while !value.nil? && relation.size > 0
         value = value.send(relation.shift)
       end
-      return value.try(relation_primary_key(first_relation).to_sym)
+      return value.try(relation_primary_key(first_relation, source: obj, was: was).to_sym)
     end
 
     # gets the reflect object on the given relation
@@ -136,7 +141,13 @@ module CounterCulture
         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
+
+        if relation.size > 0
+          # not necessary to do this at the last link because we won't use
+          # klass again. not calling this avoids the following causing an
+          # exception in the now-supported one-level polymorphic counter cache
+          klass = reflect.klass
+        end
       end
 
       return reflect
@@ -146,8 +157,51 @@ module CounterCulture
     #
     # relation: a symbol or array of symbols; specifies the relation
     #   that has the counter cache column
-    def relation_klass(relation)
-      relation_reflect(relation).klass
+    # source [optional]: the source object,
+    #   only needed for polymorphic associations,
+    #   probably only works with a single relation (symbol, or array of 1 symbol)
+    # was: boolean
+    #   we're actually looking for the old value -- only can change for polymorphic relations
+    def relation_klass(relation, source: nil, was: false)
+      reflect = relation_reflect(relation)
+      if reflect.options.key?(:polymorphic)
+        raise "Can't work out relation's class without being passed object (relation: #{relation}, reflect: #{reflect})" if source.nil?
+        raise "Can't work out polymorhpic relation's class with multiple relations yet" unless (relation.is_a?(Symbol) || relation.length == 1)
+        # this is the column that stores the polymorphic type, aka the class name
+        type_column = reflect.foreign_type.to_sym
+        # so now turn that into the class that we're looking for here
+        if was
+          attribute_was(source, type_column).constantize
+        else
+          source.public_send(type_column).constantize
+        end
+      else
+        reflect.klass
+      end
+    end
+
+    def first_level_relation_changed?(instance)
+      return true if attribute_changed?(instance, first_level_relation_foreign_key)
+      if polymorphic?
+        return true if attribute_changed?(instance, first_level_relation_foreign_type)
+      end
+      false
+    end
+
+    def attribute_changed?(obj, attr)
+      if Rails.version >= "5.1.0"
+        obj.saved_changes[attr].present?
+      else
+        obj.send(:attribute_changed?, attr)
+      end
+    end
+
+    def polymorphic?
+      is_polymorphic = relation_reflect(relation).options.key?(:polymorphic)
+      if is_polymorphic && !(relation.is_a?(Symbol) || relation.length == 1)
+        raise "Polymorphic associations only supported with one level"
+      end
+      return is_polymorphic
     end
 
     # gets the foreign key name of the given relation
@@ -162,8 +216,20 @@ module CounterCulture
     #
     # relation: a symbol or array of symbols; specifies the relation
     #   that has the counter cache column
-    def relation_primary_key(relation)
-      relation_reflect(relation).association_primary_key
+    # source[optional]: the model instance that the relationship is linked from,
+    #   only needed for polymorphic associations,
+    #   probably only works with a single relation (symbol, or array of 1 symbol)
+    # was: boolean
+    #   we're actually looking for the old value -- only can change for polymorphic relations
+    def relation_primary_key(relation, source: nil, was: false)
+      reflect = relation_reflect(relation)
+      klass = nil
+      if reflect.options.key?(:polymorphic)
+        raise "can't handle multiple keys with polymorphic associations" unless (relation.is_a?(Symbol) || relation.length == 1)
+        raise "must specify source for polymorphic associations..." unless source
+        return relation_klass(relation, source: source, was: was).primary_key
+      end
+      reflect.association_primary_key(klass)
     end
 
     # gets the foreign key name of the relation. will look at the first
@@ -177,6 +243,12 @@ module CounterCulture
       relation_reflect(first_relation).foreign_key
     end
 
+    def first_level_relation_foreign_type
+      return nil unless polymorphic?
+      first_relation = relation.first if relation.is_a?(Enumerable)
+      relation_reflect(first_relation).foreign_type
+    end
+
     def previous_model(obj)
       prev = obj.dup
 
@@ -190,7 +262,6 @@ module CounterCulture
     end
 
     private
-
     def execute_change_counter_cache(obj, options)
       if execute_after_commit
         obj.execute_after_commit { yield }

data/lib/counter_culture/extensions.rb

@@ -111,14 +111,9 @@ module CounterCulture
           counter_cache_name_was = counter.counter_cache_name_for(counter.previous_model(self))
           counter_cache_name = counter.counter_cache_name_for(self)
 
-          if Rails.version >= "5.1.0"
-            foreign_key_changed = saved_changes[counter.first_level_relation_foreign_key].present?
-            delta_column_changed = (counter.delta_column && saved_changes[counter.delta_column].present?)
-          else
-            foreign_key_changed = attribute_changed?(counter.first_level_relation_foreign_key)
-            delta_column_changed = (counter.delta_column && attribute_changed?(counter.delta_column))
-          end
-          if foreign_key_changed || delta_column_changed || counter_cache_name != counter_cache_name_was
+          if counter.first_level_relation_changed?(self) ||
+              (counter.delta_column && counter.attribute_changed?(self, counter.delta_column)) ||
+              counter_cache_name != counter_cache_name_was
 
             # increment the counter cache of the new value
             counter.change_counter_cache(self, :increment => true, :counter_column => counter_cache_name)

data/lib/counter_culture/reconciler.rb

@@ -5,7 +5,7 @@ module CounterCulture
   class Reconciler
     attr_reader :counter, :options, :changes
 
-    delegate :model, :relation, :full_primary_key, :relation_reflect, :to => :counter
+    delegate :model, :relation, :full_primary_key, :relation_reflect, :polymorphic?, :to => :counter
     delegate *CounterCulture::Counter::CONFIG_OPTIONS, :to => :counter
 
     def initialize(counter, options={})
@@ -26,117 +26,166 @@ module CounterCulture
         raise "Fixing counter caches is not supported when :delta_magnitude is a Proc; you may skip this relation with :skip_unsupported => true" if delta_magnitude.is_a?(Proc)
       end
 
-      # if we're provided a custom set of column names with conditions, use them; just use the
-      # column name otherwise
-      # which class does this relation ultimately point to? that's where we have to start
+      associated_model_classes.each do |associated_model_class|
+        Reconciliation.new(counter, changes, options, associated_model_class).perform
+      end
 
-      scope = relation_class
+      @reconciled = true
+    end
 
-      # respect the deleted_at column if it exists
-      scope = scope.where("#{model.table_name}.deleted_at IS NULL") if model.column_names.include?('deleted_at')
+    private
 
-      counter_column_names = column_names || {nil => counter_cache_name}
+    def associated_model_classes
+      if polymorphic?
+        polymorphic_associated_model_classes
+      else
+        [associated_model_class]
+      end
+    end
 
-      # iterate over all the possible counter cache column names
-      counter_column_names.each do |where, column_name|
-        # if the column name is nil, that means those records don't affect
-        # counts; we don't need to do anything in that case. but we allow
-        # specifying that condition regardless to make the syntax less
-        # confusing
-        next unless column_name
+    def polymorphic_associated_model_classes
+      foreign_type_field = relation_reflect(relation).foreign_type
+      model.pluck("DISTINCT #{foreign_type_field}").map(&:constantize)
+    end
 
-        # select join column and count (from above) as well as cache column ('column_name') for later comparison
-        counts_query = scope.select("#{relation_class.table_name}.#{relation_class.primary_key}, #{relation_class.table_name}.#{relation_reflect(relation).association_primary_key}, #{count_select} AS count, #{relation_class.table_name}.#{column_name}")
+    def associated_model_class
+      counter.relation_klass(counter.relation)
+    end
 
-        # we need to join together tables until we get back to the table this class itself lives in
-        # conditions must also be applied to the join on which we are counting
-        join_clauses.each_with_index do |join,index|
-          if index == join_clauses.size - 1 && where
-            join += " AND (#{model.send(:sanitize_sql_for_conditions, where)})"
-          end
-          counts_query = counts_query.joins(join)
-        end
 
-        # iterate in batches; otherwise we might run out of memory when there's a lot of
-        # instances and we try to load all their counts at once
-        batch_size = options.fetch(:batch_size, CounterCulture.config.batch_size)
+    class Reconciliation
+      attr_reader :counter, :options, :relation_class
 
-        counts_query.group(full_primary_key(relation_class)).find_in_batches(batch_size: batch_size) do |records|
-          # now iterate over all the models and see whether their counts are right
-          ActiveRecord::Base.transaction do
-            records.each do |record|
-              count = record.read_attribute('count') || 0
-              next if record.read_attribute(column_name) == count
+      delegate :model, :relation, :full_primary_key, :relation_reflect, :polymorphic?, :to => :counter
+      delegate *CounterCulture::Counter::CONFIG_OPTIONS, :to => :counter
 
-              track_change(record, column_name, count)
+      def initialize(counter, changes_holder, options, relation_class)
+        @counter, @options, = counter, options
+        @relation_class = relation_class
+        @changes_holder = changes_holder
+      end
 
-              # use update_all because it's faster and because a fixed counter-cache shouldn't update the timestamp
-              relation_class.where(relation_class.primary_key => record.send(relation_class.primary_key)).update_all(column_name => count)
+      def perform
+        # if we're provided a custom set of column names with conditions, use them; just use the
+        # column name otherwise
+        # which class does this relation ultimately point to? that's where we have to start
+
+        scope = relation_class
+
+        # respect the deleted_at column if it exists
+        scope = scope.where("#{model.table_name}.deleted_at IS NULL") if model.column_names.include?('deleted_at')
+
+        counter_column_names = column_names || {nil => counter_cache_name}
+
+        # iterate over all the possible counter cache column names
+        counter_column_names.each do |where, column_name|
+         # if the column name is nil, that means those records don't affect
+         # counts; we don't need to do anything in that case. but we allow
+         # specifying that condition regardless to make the syntax less
+         # confusing
+         next unless column_name
+
+          # select join column and count (from above) as well as cache column ('column_name') for later comparison
+          counts_query = scope.select("#{relation_class.table_name}.#{relation_class.primary_key}, #{relation_class.table_name}.#{relation_reflect(relation).association_primary_key(relation_class)}, #{count_select} AS count, #{relation_class.table_name}.#{column_name}")
+
+          # we need to join together tables until we get back to the table this class itself lives in
+          # conditions must also be applied to the join on which we are counting
+          join_clauses.each_with_index do |join, index|
+            if index == join_clauses.size - 1 && where
+              join += " AND (#{model.send(:sanitize_sql_for_conditions, where)})"
             end
+            counts_query = counts_query.joins(join)
           end
-        end
-      end
 
-      @reconciled = true
-    end
+          # iterate in batches; otherwise we might run out of memory when there's a lot of
+          # instances and we try to load all their counts at once
+          batch_size = options.fetch(:batch_size, CounterCulture.config.batch_size)
 
-    private
+          counts_query.group(full_primary_key(relation_class)).find_in_batches(batch_size: batch_size) do |records|
+            # now iterate over all the models and see whether their counts are right
+            ActiveRecord::Base.transaction do
+              records.each do |record|
+                count = record.read_attribute('count') || 0
+                next if record.read_attribute(column_name) == count
 
-    # keep track of what we fixed, e.g. for a notification email
-    def track_change(record, column_name, count)
-      @changes << {
-        :entity => relation_class.name,
-        relation_class.primary_key.to_sym => record.send(relation_class.primary_key),
-        :what => column_name,
-        :wrong => record.send(column_name),
-        :right => count
-      }
-    end
+                track_change(record, column_name, count)
 
-    def count_select
-      # if a delta column is provided use SUM, otherwise use COUNT
-      return @count_select if @count_select
-      if delta_column
-        @count_select = "SUM(COALESCE(#{self_table_name}.#{delta_column},0))"
-      else
-        @count_select = "COUNT(#{self_table_name}.#{model.primary_key})*#{delta_magnitude}"
+                # use update_all because it's faster and because a fixed counter-cache shouldn't update the timestamp
+                relation_class.where(relation_class.primary_key => record.send(relation_class.primary_key)).update_all(column_name => count)
+              end
+            end
+          end
+        end
       end
-    end
 
-    def relation_class
-      @relation_class ||= counter.relation_klass(counter.relation)
-    end
+      private
+
+      # keep track of what we fixed, e.g. for a notification email
+      def track_change(record, column_name, count)
+        @changes_holder << {
+          :entity => relation_class.name,
+          relation_class.primary_key.to_sym => record.send(relation_class.primary_key),
+          :what => column_name,
+          :wrong => record.send(column_name),
+          :right => count
+        }
+      end
 
-    def self_table_name
-      @self_table_name ||= if relation_class.table_name == model.table_name
-        "#{model.table_name}_#{model.table_name}"
-      else
-        model.table_name
+      def count_select
+        # if a delta column is provided use SUM, otherwise use COUNT
+        return @count_select if @count_select
+        if delta_column
+          @count_select = "SUM(COALESCE(#{self_table_name}.#{delta_column},0))"
+        else
+          @count_select = "COUNT(#{self_table_name}.#{model.primary_key})*#{delta_magnitude}"
+        end
       end
-    end
 
-    def join_clauses
-      return @join_clauses if defined?(@join_clauses)
+      def self_table_name
+        @self_table_name ||= if relation_class.table_name == model.table_name
+          "#{model.table_name}_#{model.table_name}"
+        else
+          model.table_name
+        end
+      end
 
-      # 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..relation.length).to_a.reverse.inject([]) {|a,i| a << relation[0,i]; a }
+      def join_clauses
+        return @join_clauses if defined?(@join_clauses)
 
-      # store joins in an array so that we can later apply column-specific conditions
-      @join_clauses = reverse_relation.map do |cur_relation|
-        reflect = relation_reflect(cur_relation)
-        if relation_class.table_name == reflect.active_record.table_name
-          join_table_name = "#{relation_class.table_name}_#{relation_class.table_name}"
-        else
-          join_table_name = reflect.active_record.table_name
+        # 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..relation.length).to_a.reverse.inject([]) { |a, i| a << relation[0, i]; a }
+
+        # store joins in an array so that we can later apply column-specific conditions
+        @join_clauses = reverse_relation.map do |cur_relation|
+          reflect = relation_reflect(cur_relation)
+          if relation_class.table_name == reflect.active_record.table_name
+            join_table_name = "#{relation_class.table_name}_#{relation_class.table_name}"
+          else
+            join_table_name = reflect.active_record.table_name
+          end
+          if polymorphic?
+            # NB: polymorphic only supports one level of relation (at present)
+            association_primary_key = reflect.association_primary_key(relation_class)
+            reflect_table_name = relation_class.table_name
+          else
+            association_primary_key = reflect.association_primary_key
+            reflect_table_name = reflect.table_name
+          end
+
+          # join with alias to avoid ambiguous table name with self-referential models:
+          joins_sql = "LEFT JOIN #{reflect.active_record.table_name} AS #{join_table_name} ON #{reflect_table_name}.#{association_primary_key} = #{join_table_name}.#{reflect.foreign_key}"
+          # adds 'type' condition to JOIN clause if the current model is a child in a Single Table Inheritance
+          joins_sql = "#{joins_sql} AND #{reflect.active_record.table_name}.type IN ('#{model.name}')" if reflect.active_record.column_names.include?('type') && !model.descends_from_active_record?
+          if polymorphic?
+            # adds 'type' condition to JOIN clause if the current model is a polymorphic relation
+            # NB only works for one-level relations
+            joins_sql = "#{joins_sql} AND #{reflect.active_record.table_name}.#{reflect.foreign_type} = '#{relation_class.name}'"
+          end
+          joins_sql
         end
-        # join with alias to avoid ambiguous table name with self-referential models:
-        joins_sql = "LEFT JOIN #{reflect.active_record.table_name} AS #{join_table_name} ON #{reflect.table_name}.#{reflect.association_primary_key} = #{join_table_name}.#{reflect.foreign_key}"
-        # adds 'type' condition to JOIN clause if the current model is a child in a Single Table Inheritance
-        joins_sql = "#{joins_sql} AND #{reflect.active_record.table_name}.type IN ('#{model.name}')" if reflect.active_record.column_names.include?('type') && !model.descends_from_active_record?
-        joins_sql
       end
-    end
 
+    end
   end
 end

data/spec/counter_culture_spec.rb

@@ -1585,4 +1585,157 @@ describe "CounterCulture" do
       ])
     end
   end
+
+  describe "with polymorphic_associations" do
+    before(:all) do
+      require 'models/poly_image'
+      require 'models/poly_employee'
+      require 'models/poly_product'
+    end
+    let(:employee) { PolyEmployee.create(id: 3000) }
+    let(:product1) { PolyProduct.create() }
+    let(:product2) { PolyProduct.create() }
+    let(:special_url) { "http://images.example.com/special.png" }
+
+    def mess_up_counts
+      PolyEmployee.update_all(poly_images_count: 100, poly_images_count_dup: 100, special_poly_images_count: 100)
+      PolyProduct.update_all(poly_images_count: 100, poly_images_count_dup: 100, special_poly_images_count: 100)
+    end
+
+    describe "default" do
+      it "increments / decrements counter caches correctly" do
+        expect(employee.poly_images_count).to eq(0)
+        expect(product1.poly_images_count).to eq(0)
+        img1 = PolyImage.create(imageable: employee)
+        expect(employee.reload.poly_images_count).to eq(1)
+        expect(product1.reload.poly_images_count).to eq(0)
+        img2 = PolyImage.create(imageable: product1)
+        expect(employee.reload.poly_images_count).to eq(1)
+        expect(product1.reload.poly_images_count).to eq(1)
+        img3 = PolyImage.create(imageable: product1)
+        expect(employee.reload.poly_images_count).to eq(1)
+        expect(product1.reload.poly_images_count).to eq(2)
+        img3.destroy
+        expect(employee.reload.poly_images_count).to eq(1)
+        expect(product1.reload.poly_images_count).to eq(1)
+        img2.imageable = employee
+        img2.save!
+        expect(employee.reload.poly_images_count).to eq(2)
+        expect(product1.reload.poly_images_count).to eq(0)
+      end
+
+      it "decrements counter caches on update correctly" do
+        img = PolyImage.create(imageable: product1)
+        img.imageable = employee
+        img.save!
+        expect(product1.reload.poly_images_count).to eq(0)
+        expect(employee.reload.poly_images_count).to eq(1)
+      end
+
+      it "can fix counts for polymorphic correctly" do
+        2.times { PolyImage.create(imageable: employee) }
+        1.times { PolyImage.create(imageable: product1) }
+        mess_up_counts
+
+        PolyImage.counter_culture_fix_counts
+
+        expect(product2.reload.poly_images_count).to eq(0)
+        expect(product1.reload.poly_images_count).to eq(1)
+        expect(employee.reload.poly_images_count).to eq(2)
+      end
+    end
+    describe "custom column name" do
+      it "increments counter cache on create" do
+        expect(employee.poly_images_count_dup).to eq(0)
+        expect(product1.poly_images_count_dup).to eq(0)
+        img1 = PolyImage.create(imageable: employee)
+        expect(employee.reload.poly_images_count_dup).to eq(1)
+        expect(product1.reload.poly_images_count_dup).to eq(0)
+        img2 = PolyImage.create(imageable: product1)
+        expect(employee.reload.poly_images_count_dup).to eq(1)
+        expect(product1.reload.poly_images_count_dup).to eq(1)
+        img3 = PolyImage.create(imageable: product1)
+        expect(employee.reload.poly_images_count_dup).to eq(1)
+        expect(product1.reload.poly_images_count_dup).to eq(2)
+        img3.destroy
+        expect(employee.reload.poly_images_count_dup).to eq(1)
+        expect(product1.reload.poly_images_count_dup).to eq(1)
+        img2.imageable = employee
+        img2.save!
+        expect(employee.reload.poly_images_count_dup).to eq(2)
+        expect(product1.reload.poly_images_count_dup).to eq(0)
+      end
+
+      it "decrements counter caches on update correctly" do
+        img = PolyImage.create(imageable: product1)
+        img.imageable = employee
+        img.save!
+        expect(employee.reload.poly_images_count_dup).to eq(1)
+        expect(product1.reload.poly_images_count_dup).to eq(0)
+      end
+
+      it "can fix counts for polymorphic correctly" do
+        2.times { PolyImage.create(imageable: employee) }
+        1.times { PolyImage.create(imageable: product1) }
+        mess_up_counts
+
+        PolyImage.counter_culture_fix_counts
+
+        expect(product2.reload.poly_images_count_dup).to eq(0)
+        expect(product1.reload.poly_images_count_dup).to eq(1)
+        expect(employee.reload.poly_images_count_dup).to eq(2)
+      end
+    end
+    describe "conditional counts" do
+      it "increments counter cache on create" do
+        expect(employee.special_poly_images_count).to eq(0)
+        expect(product1.special_poly_images_count).to eq(0)
+        PolyImage.create(imageable: employee)
+        expect(employee.reload.special_poly_images_count).to eq(0)
+        expect(product1.special_poly_images_count).to eq(0)
+        PolyImage.create(imageable: product1)
+        expect(employee.reload.special_poly_images_count).to eq(0)
+        expect(product1.reload.special_poly_images_count).to eq(0)
+        img1 = PolyImage.create(imageable: employee, url: special_url)
+        expect(employee.reload.special_poly_images_count).to eq(1)
+        expect(product1.special_poly_images_count).to eq(0)
+        img2 = PolyImage.create(imageable: product1, url: special_url)
+        expect(employee.reload.special_poly_images_count).to eq(1)
+        expect(product1.reload.special_poly_images_count).to eq(1)
+        img2.destroy
+        expect(employee.reload.special_poly_images_count).to eq(1)
+        expect(product1.reload.special_poly_images_count).to eq(0)
+        img1.imageable = product1
+        img1.save!
+        expect(employee.reload.special_poly_images_count).to eq(0)
+        expect(product1.reload.special_poly_images_count).to eq(1)
+      end
+
+      it "can fix counts for polymorphic correctly" do
+        4.times { PolyImage.create(imageable: employee) }
+        2.times { PolyImage.create(imageable: employee, url: special_url) }
+        1.times { PolyImage.create(imageable: product1) }
+        1.times { PolyImage.create(imageable: product1, url: special_url) }
+        mess_up_counts
+
+        PolyImage.counter_culture_fix_counts
+
+        expect(product2.reload.special_poly_images_count).to eq(0)
+        expect(employee.reload.special_poly_images_count).to eq(2)
+        expect(product1.reload.special_poly_images_count).to eq(1)
+      end
+
+      it "can deal with changes to condition" do
+        img1 = PolyImage.create(imageable: employee)
+        expect {img1.update_attributes!(url: special_url)}
+          .to change { employee.reload.special_poly_images_count }.from(0).to(1)
+      end
+
+      it "can deal with changes to condition" do
+        img1 = PolyImage.create(imageable: employee, url: special_url)
+        expect {img1.update_attributes!(url: "normal url")}
+          .to change { employee.reload.special_poly_images_count }.from(1).to(0)
+      end
+    end
+  end
 end

data/spec/models/poly_employee.rb

@@ -0,0 +1,3 @@
+class PolyEmployee < ActiveRecord::Base
+  has_many :poly_images, as: :imageable
+end

data/spec/models/poly_image.rb

@@ -0,0 +1,15 @@
+class PolyImage < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+  counter_culture :imageable
+  counter_culture :imageable, column_name: 'poly_images_count_dup'
+  counter_culture :imageable, column_name: ->(i){i.special? ? 'special_poly_images_count' : nil },
+    column_names: {
+        ["poly_images.url LIKE ?", '%special%'] => 'special_poly_images_count',
+    }
+
+
+  def special?
+    url && url.include?('special')
+  end
+
+end

data/spec/models/poly_product.rb

@@ -0,0 +1,4 @@
+class PolyProduct < ActiveRecord::Base
+  self.primary_key = :pp_pk_id
+  has_many :poly_images, as: :imageable
+end

data/spec/schema.rb

@@ -174,4 +174,23 @@ ActiveRecord::Schema.define(:version => 20120522160158) do
     t.integer "person_id", :null => false
     t.integer "monetary_value", :null => false
   end
+
+  #polymorphic
+  create_table "poly_images", :force => true do |t|
+    t.integer "imageable_id", :null => true
+    t.string "imageable_type", :null => true
+    t.string "url"
+  end
+  create_table "poly_employees", :force => true do |t|
+    t.string "name"
+    t.integer  "poly_images_count", :default => 0, :null => false
+    t.integer  "poly_images_count_dup", :default => 0, :null => false
+    t.integer  "special_poly_images_count", :default => 0, :null => false
+  end
+  create_table "poly_products", :primary_key => 'pp_pk_id', :force => true do |t|
+    t.string "brand_name"
+    t.integer  "poly_images_count", :default => 0, :null => false
+    t.integer  "poly_images_count_dup", :default => 0, :null => false
+    t.integer  "special_poly_images_count", :default => 0, :null => false
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Magnus von Koeller
@@ -204,6 +204,9 @@ files:
 - spec/models/has_string_id.rb
 - spec/models/industry.rb
 - spec/models/person.rb
+- spec/models/poly_employee.rb
+- spec/models/poly_image.rb
+- spec/models/poly_product.rb
 - spec/models/post.rb
 - spec/models/post_comment.rb
 - spec/models/product.rb