activerecord-precount 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9a9eb42c1ba767640277c85e4f3ac5253e4527b
-  data.tar.gz: 94b98083c83b85e45e1349c88d8560311d3c2d79
+  metadata.gz: b261414eec5a1fd723fb2fcea8cbe708c48415ca
+  data.tar.gz: 1d522f1cb7b9a7f0ac94d479feed434805d3077f
 SHA512:
-  metadata.gz: c743dde55020595f377651df070394db415ea62f6ef12614d5eaca8b0bb4a5c2b6861d426bf5d87122e652511868b1c9c4d166bb26f70aa077a28e3bb7c7de82
-  data.tar.gz: fc1020127a928f74bf6f99846f542d469e5664a4d10a6341d6316c9759d2d912d43b49435ac65939ea22f197ac3d42c63c5bf2b7bb9267276f59a0a673a141c1
+  metadata.gz: 9ddc79eeb3385aa2be6a1973c5e1bb11dba1fe123e3e9e6064fb3c16445922ff8273d8268a0ca37a8801b31fa9edd3cb5f70c091f5f3d23efa8fa2d4fde7915e
+  data.tar.gz: 4340c6a29f8040a154d1f6d6c5a401064efc60bfab6ec654c808da6a2e58fc804c834507d8c2d35229034ead2dc72340e85218eaa31fd053f91d7a9a3d59c99a

data/CHANGELOG.md

@@ -0,0 +1,87 @@
+# Change Log
+
+## [v0.6.1](https://github.com/k0kubun/activerecord-precount/tree/v0.6.1) (2016-06-02)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.6.0...v0.6.1)
+
+- Support polymorphic association for `precount` [\#17](https://github.com/k0kubun/activerecord-precount/pull/17)
+
+## [v0.6.0](https://github.com/k0kubun/activerecord-precount/tree/v0.6.0) (2016-06-02)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.5.1...v0.6.0)
+
+- Support Rails 5.0 [\#14](https://github.com/k0kubun/activerecord-precount/pull/14) ([k0kubun](https://github.com/k0kubun))
+  - Drop Rails 4.1 support
+
+## [v0.5.1](https://github.com/k0kubun/activerecord-precount/tree/v0.5.1) (2015-09-09)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.5.0...v0.5.1)
+
+- Support an association with a scope [\#10](https://github.com/k0kubun/activerecord-precount/pull/10) ([tkawa](https://github.com/tkawa))
+
+## [v0.5.0](https://github.com/k0kubun/activerecord-precount/tree/v0.5.0) (2015-02-01)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.4.3...v0.5.0)
+
+- Add `eager_count` method for eager loading by JOIN
+
+## [v0.4.3](https://github.com/k0kubun/activerecord-precount/tree/v0.4.3) (2015-01-31)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.4.2...v0.4.3)
+
+## [v0.4.2](https://github.com/k0kubun/activerecord-precount/tree/v0.4.2) (2015-01-31)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.4.1...v0.4.2)
+
+## [v0.4.1](https://github.com/k0kubun/activerecord-precount/tree/v0.4.1) (2015-01-31)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.4.0...v0.4.1)
+
+## [v0.4.0](https://github.com/k0kubun/activerecord-precount/tree/v0.4.0) (2015-01-31)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.3.3...v0.4.0)
+
+## [v0.3.3](https://github.com/k0kubun/activerecord-precount/tree/v0.3.3) (2015-01-31)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.3.2...v0.3.3)
+
+## [v0.3.2](https://github.com/k0kubun/activerecord-precount/tree/v0.3.2) (2015-01-30)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.3.1...v0.3.2)
+
+## [v0.3.1](https://github.com/k0kubun/activerecord-precount/tree/v0.3.1) (2015-01-08)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.3.0...v0.3.1)
+
+## [v0.3.0](https://github.com/k0kubun/activerecord-precount/tree/v0.3.0) (2015-01-08)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.2.2...v0.3.0)
+
+**Closed issues:**
+
+- Rails 4.2.0 [\#8](https://github.com/k0kubun/activerecord-precount/issues/8)
+
+## [v0.2.2](https://github.com/k0kubun/activerecord-precount/tree/v0.2.2) (2014-11-23)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.2.1...v0.2.2)
+
+## [v0.2.1](https://github.com/k0kubun/activerecord-precount/tree/v0.2.1) (2014-11-23)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.2.0...v0.2.1)
+
+**Merged pull requests:**
+
+- Add test cases [\#7](https://github.com/k0kubun/activerecord-precount/pull/7) ([k0kubun](https://github.com/k0kubun))
+
+## [v0.2.0](https://github.com/k0kubun/activerecord-precount/tree/v0.2.0) (2014-11-22)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.1.0...v0.2.0)
+
+**Merged pull requests:**
+
+- Change API [\#6](https://github.com/k0kubun/activerecord-precount/pull/6) ([k0kubun](https://github.com/k0kubun))
+
+## [v0.1.0](https://github.com/k0kubun/activerecord-precount/tree/v0.1.0) (2014-11-20)
+[Full Changelog](https://github.com/k0kubun/activerecord-precount/compare/v0.0.5...v0.1.0)
+
+**Merged pull requests:**
+
+- Support :class\_name option on has\_count [\#5](https://github.com/k0kubun/activerecord-precount/pull/5) ([r7kamura](https://github.com/r7kamura))
+
+## [v0.0.5](https://github.com/k0kubun/activerecord-precount/tree/v0.0.5) (2014-11-13)
+**Closed issues:**
+
+- Select limited columns [\#3](https://github.com/k0kubun/activerecord-precount/issues/3)
+
+**Merged pull requests:**
+
+- Support `has\_count :xxx, foreign\_key: :yyy` [\#4](https://github.com/k0kubun/activerecord-precount/pull/4) ([r7kamura](https://github.com/r7kamura))
+
+
+
+\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

data/README.md

@@ -32,7 +32,7 @@ Like `preload`, it loads counts by multiple queries
 
 ```rb
 Tweet.all.precount(:favorites).each do |tweet|
-  p tweet.favorites.count
+  p tweet.favorites_count
 end
 # SELECT `tweets`.* FROM `tweets`
 # SELECT COUNT(`favorites`.`tweet_id`), `favorites`.`tweet_id` FROM `favorites` WHERE `favorites`.`tweet_id` IN (1, 2, 3, 4, 5) GROUP BY `favorites`.`tweet_id`
@@ -44,7 +44,7 @@ Like `eager_load`, `eager_count` method allows you to load counts by one JOIN qu
 
 ```rb
 Tweet.all.eager_count(:favorites).each do |tweet|
-  p tweet.favorites.count
+  p tweet.favorites_count
 end
 # SELECT `tweets`.`id` AS t0_r0, `tweets`.`tweet_id` AS t0_r1, `tweets`.`user_id` AS t0_r2, `tweets`.`created_at` AS t0_r3, `tweets`.`updated_at` AS t0_r4, COUNT(`favorites`.`id`) AS t1_r0 FROM `tweets` LEFT OUTER JOIN `favorites` ON `favorites`.`tweet_id` = `tweets`.`id` GROUP BY tweets.id
 ```
@@ -114,7 +114,7 @@ With this condition, you can eagerly load nested association by preload.
 Hoge.preload(foo: :bars_count)
 ```
 
-### Performance issue
+### `count` method is not recommended
 
 With activerecord-precount gem installed, `bars.count` fallbacks to `bars_count` if `bars_count` is defined.
 Though precounted `bars.count` is faster than not-precounted one, the fallback is currently much slower than just calling `bars_count`.

data/lib/active_record/precount.rb

@@ -1,7 +1,33 @@
 require "active_support/lazy_load_hooks"
 
+# How it works:
+#
+# 1. has_many :foo, count_loader: true
+#   * has_many_extension:         Create and add a reflection for :count_loader in has_many method
+#     * reflection_extension:       CountLoaderReflection is required in reflection creation
+#   * reflection_extension:       Return CountLoaderReflection in Reflection.create
+#     * reflection_extension:       CountLoader#load_target loads counts when not eager-loaded
+#     * preloader_extension:        Return CountLoader preloader and preload in it
+#     * relation_extension:         Apply GROUP in #apply_join_dependency for eager_load
+#     * join_dependency_extension:  Use COUNT query in #aliases for eager_load and map it in #construct
+#       * collection_proxy_extension: Fallback to eager-loaded values when foo.count is called
+#
+# 2. precount(:foo)
+#   * relation_extension:         Add #precount query method, which defines count_loader association and adds preload_values
+#     * base_extension:             Delegate it for class method
+#   * reflection_extension:       Return CountLoaderReflection in Reflection.create
+#     * preloader_extension:        Return CountLoader preloader and preload in it
+#       * collection_proxy_extension: Fallback to eager-loaded values when foo.count is called
+#
+# 3. eager_count(:foo)
+#   * relation_extension:         Add #eager_count query method, which defines count_loader association and adds eager_load_values
+#     * base_extension:             Delegate it for class method
+#   * reflection_extension:       Return CountLoaderReflection in Reflection.create
+#     * relation_extension:         Apply GROUP in #apply_join_dependency for eager_load
+#     * join_dependency_extension:  Use COUNT query in #aliases for eager_load and map it in #construct
+#       * collection_proxy_extension: Fallback to eager-loaded values when foo.count is called
+#
 ActiveSupport.on_load(:active_record) do
-  require "active_record/precount/association_reflection_extension"
   require "active_record/precount/base_extension"
   require "active_record/precount/collection_proxy_extension"
   require "active_record/precount/has_many_extension"

data/lib/active_record/precount/base_extension.rb

@@ -2,16 +2,8 @@ module ActiveRecord
   module Precount
     module BaseExtension
       delegate :precount, :eager_count, to: :all
-
-      def has_reflection?(name)
-        reflection_for(name).present?
-      end
-
-      def reflection_for(name)
-        reflections[name.to_s]
-      end
     end
   end
 
-  Base.send(:extend, Precount::BaseExtension)
+  Base.extend(Precount::BaseExtension)
 end

data/lib/active_record/precount/collection_proxy_extension.rb

@@ -1,16 +1,16 @@
+require 'active_record/precount/reflection_checker'
+
 module ActiveRecord
   module Precount
     module CollectionProxyExtension
       def count(*args)
-        return super(*args) if args.present?
+        return super if args.present?
 
         counter_name = :"#{@association.reflection.name}_count"
-        owner        = @association.owner
-
-        if owner.class.has_reflection?(counter_name) && owner.association(counter_name).loaded?
-          owner.association(counter_name).target
+        if ReflectionChecker.count_loaded?(@association.owner, counter_name)
+          @association.owner.association(counter_name).target
         else
-          super(*args)
+          super
         end
       end
     end

data/lib/active_record/precount/count_loader_builder.rb

@@ -0,0 +1,66 @@
+require 'active_record/precount/reflection_checker'
+
+module ActiveRecord
+  module Precount
+    class CountLoaderBuilder
+      def initialize(model)
+        @model = model
+      end
+
+      def build_from_has_many(name, scope, options)
+        name_with_count =
+          if options[:count_loader].is_a?(Symbol)
+            options[:count_loader]
+          else
+            :"#{name}_count"
+          end
+
+        add_reflection(name_with_count, scope, options)
+      end
+
+      def build_from_query_methods(*args)
+        args.each do |arg|
+          next if ReflectionChecker.has_reflection?(@model, counter_name = :"#{arg}_count")
+          unless ReflectionChecker.has_reflection?(@model, arg)
+            raise ArgumentError, "Association named '#{arg}' was not found on #{@model.name}."
+          end
+
+          original_reflection = @model.reflections[arg.to_s]
+          add_reflection(counter_name, original_reflection.scope, original_reflection.options)
+        end
+      end
+
+      private
+
+      def add_reflection(name, scope, options)
+        valid_options = options.slice(*Associations::Builder::CountLoader.valid_options)
+        reflection = Associations::Builder::CountLoader.build(@model, name, scope, valid_options)
+        Reflection.add_reflection(@model, name, reflection)
+      end
+    end
+  end
+
+  module Associations
+    module Builder
+      class CountLoader < SingularAssociation
+        def self.valid_options(*)
+          [:class, :class_name, :foreign_key]
+        end
+
+        if ActiveRecord.version.segments.first >= 5
+          def self.macro
+            :count_loader
+          end
+        else
+          def macro
+            :count_loader
+          end
+        end
+
+        def self.valid_dependent_options
+          []
+        end
+      end
+    end
+  end
+end

data/lib/active_record/precount/has_many_extension.rb

@@ -1,78 +1,40 @@
-module ActiveRecord
-  module Associations
-    module Builder
-      class CountLoader < SingularAssociation
-        def self.valid_options(*)
-          [:class, :class_name, :foreign_key]
-        end
-
-        if ActiveRecord.version.segments.first >= 5
-          def self.macro
-            :count_loader
-          end
-        else
-          def macro
-            :count_loader
-          end
-        end
-
-        def self.valid_dependent_options
-          []
-        end
-      end
-    end
-  end
+require 'active_record/precount/count_loader_builder'
 
+module ActiveRecord
   module Precount
     module Builder
-      module Rails4HasManyExtension
-        def valid_options
-          super + [:count_loader]
-        end
-
-        def build(model)
-          define_count_loader(model) if options[:count_loader]
-          super
-        end
-
-        def define_count_loader(model)
-          name_with_count = :"#{name}_count"
-          name_with_count = options[:count_loader] if options[:count_loader].is_a?(Symbol)
-
-          valid_options = options.slice(*Associations::Builder::CountLoader.valid_options)
-          reflection = Associations::Builder::CountLoader.build(model, name_with_count, scope, valid_options)
-          Reflection.add_reflection(model, name_with_count, reflection)
-        end
-      end
-
-      module Rails5HasManyExtension
+      module HasManyExtension
         def valid_options(*)
           super + [:count_loader]
         end
 
-        def build(model, name, scope, options, &block)
-          if scope.is_a?(Hash)
-            options = scope
-            scope   = nil
+        if ActiveRecord.version.segments.first >= 5
+          def build(model, name, scope, options, &block)
+            if scope.is_a?(Hash)
+              options = scope
+              scope   = nil
+            end
+
+            if options[:count_loader]
+              CountLoaderBuilder.new(model).build_from_has_many(name, scope, options)
+            end
+            super
           end
-
-          if options[:count_loader]
-            name_with_count = :"#{name}_count"
-            name_with_count = options[:count_loader] if options[:count_loader].is_a?(Symbol)
-
-            valid_options = options.slice(*Associations::Builder::CountLoader.valid_options)
-            reflection = Associations::Builder::CountLoader.build(model, name_with_count, scope, valid_options)
-            Reflection.add_reflection(model, name_with_count, reflection)
+        else
+          def build(model)
+            if options[:count_loader]
+              CountLoaderBuilder.new(model).build_from_has_many(name, scope, options)
+            end
+            super
           end
-          super
         end
       end
     end
   end
 
   if ActiveRecord.version.segments.first >= 5
-    Associations::Builder::HasMany.send(:extend, Precount::Builder::Rails5HasManyExtension)
+    Associations::Builder::HasMany.extend(Precount::Builder::HasManyExtension)
   else
-    Associations::Builder::HasMany.prepend(Precount::Builder::Rails4HasManyExtension)
+    Associations::Builder::HasMany.prepend(Precount::Builder::HasManyExtension)
   end
 end

data/lib/active_record/precount/join_dependency_extension.rb

@@ -42,7 +42,7 @@ module ActiveRecord
         return if normal_children.blank?
 
         normal_parent = Associations::JoinDependency::JoinBase.new(parent.base_klass, normal_children)
-        super(ar_parent, normal_parent, row, rs, seen, model_cache, aliases)
+        super
       end
     end
   end

data/lib/active_record/precount/preloader_extension.rb

@@ -2,23 +2,42 @@ module ActiveRecord
   module Associations
     class Preloader
       class CountLoader < SingularAssociation
-        if ActiveRecord.version.segments.first >= 5
-          def association_key_name
-            reflection.foreign_key
-          end
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        private
 
-          def owner_key_name
-            reflection.active_record_primary_key
+        def key_conversion_required?
+          # Are you sure this is always false? But this method is required to map result for polymorphic association.
+          false
+        end
+
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, associated_records|
+            owner.association(reflection.name).target = associated_records.first.to_i
           end
+        end
 
-          private
+        def query_scope(ids)
+          key = model.reflections[reflection.name.to_s.sub(/_count\z/, '')].foreign_key
+          scope.where(key => ids).group(key).count(key)
+        end
 
-          def preload(preloader)
-            associated_records_by_owner(preloader).each do |owner, associated_records|
-              owner.association(reflection.name).target = associated_records.first.to_i
+        def build_scope
+          super.tap do |scope|
+            has_many_reflection = model.reflections[reflection.name.to_s.sub(/_count\z/, '')]
+            if has_many_reflection.options[:as]
+              scope.where!(klass.table_name => { has_many_reflection.type => model.base_class.sti_name })
             end
           end
+        end
 
+        if ActiveRecord.version.segments.first >= 5
           def load_records
             return {} if owner_keys.empty?
 
@@ -29,27 +48,7 @@ module ActiveRecord
 
             Hash[@preloaded_records.first.map { |key, count| [key, [count]] }]
           end
-
-          def query_scope(ids)
-            scope.where(association_key.in(ids)).group(association_key_name).count(association_key_name)
-          end
         else
-          def association_key_name
-            reflection.foreign_key
-          end
-
-          def owner_key_name
-            reflection.active_record_primary_key
-          end
-
-          private
-
-          def preload(preloader)
-            associated_records_by_owner(preloader).each do |owner, associated_records|
-              owner.association(reflection.name).target = associated_records.first.to_i
-            end
-          end
-
           def load_slices(slices)
             @preloaded_records = slices.flat_map { |slice|
               records_for(slice)
@@ -59,10 +58,6 @@ module ActiveRecord
               [count, key]
             }
           end
-
-          def query_scope(ids)
-            scope.where(association_key.in(ids)).group(association_key_name).count(association_key_name)
-          end
         end
       end
     end
@@ -71,7 +66,7 @@ module ActiveRecord
   module Precount
     module PreloaderExtension
       def preloader_for(reflection, owners, rhs_klass)
-        preloader = super(reflection, owners, rhs_klass)
+        preloader = super
         return preloader if preloader
 
         case reflection.macro

data/lib/active_record/precount/reflection_checker.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Precount
+    module ReflectionChecker
+      class << self
+        def has_reflection?(klass, name)
+          klass.reflections[name.to_s].present?
+        end
+
+        def count_loaded?(owner, name)
+          has_reflection?(owner.class, name) && owner.association(name).loaded?
+        end
+      end
+    end
+  end
+end

data/lib/active_record/precount/reflection_extension.rb

@@ -1,11 +1,31 @@
 module ActiveRecord
+  module Associations
+    class CountLoader < SingularAssociation
+      # Not preloaded behaviour of count_loader association
+      # When this method is called, it will be N+1 query
+      def load_target
+        count_target = reflection.name.to_s.sub(/_count\z/, '').to_sym
+        @target = owner.association(count_target).count
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+    end
+  end
+
   module Reflection
     class CountLoaderReflection < AssociationReflection
-      def initialize(name, scope, options, active_record)
-        super(name, scope, options, active_record)
+      def macro; :count_loader; end
+
+      def association_class
+        ActiveRecord::Associations::CountLoader
       end
 
-      def macro; :count_loader; end
+      def klass
+        @klass ||= active_record.send(:compute_type, options[:class_name] || name.to_s.sub(/_count\z/, '').singularize.classify)
+      end
     end
   end
 
@@ -23,7 +43,7 @@ module ActiveRecord
           when :count_loader
             Reflection::CountLoaderReflection.new(name, scope, options, ar)
           else
-            super(macro, name, scope, options, ar)
+            super
           end
         end
       end

data/lib/active_record/precount/relation_extension.rb

@@ -1,3 +1,5 @@
+require 'active_record/precount/count_loader_builder'
+
 module ActiveRecord
   module Precount
     module RelationExtension
@@ -7,7 +9,7 @@ module ActiveRecord
       end
 
       def precount!(*args)
-        define_count_loader!(*args)
+        CountLoaderBuilder.new(klass).build_from_query_methods(*args)
 
         self.preload_values += args.map { |arg| :"#{arg}_count" }
         self
@@ -19,7 +21,7 @@ module ActiveRecord
       end
 
       def eager_count!(*args)
-        define_count_loader!(*args)
+        CountLoaderBuilder.new(klass).build_from_query_methods(*args)
 
         self.eager_load_values += args.map { |arg| :"#{arg}_count" }
         self
@@ -27,21 +29,8 @@ module ActiveRecord
 
       private
 
-      def define_count_loader!(*args)
-        args.each do |arg|
-          raise ArgumentError, "Association named '#{arg}' was not found on #{klass.name}." unless has_reflection?(arg)
-          next if has_reflection?(counter_name = :"#{arg}_count")
-
-          original_reflection = reflection_for(arg)
-          scope = original_reflection.scope
-          options = original_reflection.options.slice(*Associations::Builder::CountLoader.valid_options)
-          reflection = Associations::Builder::CountLoader.build(klass, counter_name, scope, options)
-          Reflection.add_reflection(model, counter_name, reflection)
-        end
-      end
-
       def apply_join_dependency(relation, join_dependency)
-        relation = super(relation, join_dependency)
+        relation = super
 
         # to count associated records in JOIN query, group scope is necessary
         join_dependency.reflections.each do |reflection|

data/lib/active_record/precount/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Precount
-    VERSION = "0.6.0"
+    VERSION = "0.6.1"
   end
 end

data/sample/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'rails', '4.2.0'
+gem 'rails', '4.2.6'
 gem 'mysql2'
 gem 'sass-rails', '~> 4.0.3'
 gem 'uglifier', '>= 1.3.0'

data/sample/app/models/blog.rb

@@ -0,0 +1,3 @@
+class Blog < ActiveRecord::Base
+  has_many :comments, as: :commentable
+end

data/sample/app/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  belongs_to :commentable, polymorphic: true
+end

data/sample/app/models/page.rb

@@ -0,0 +1,3 @@
+class Page < ActiveRecord::Base
+  has_many :comments, as: :commentable
+end

data/sample/config/database.yml

@@ -4,7 +4,7 @@ default: &default
   pool: 5
   username: root
   password:
-  socket: /tmp/mysql.sock
+  socket: /var/run/mysqld/mysqld.sock
 
 development:
   <<: *default

data/sample/db/migrate/20160603161811_create_blogs.rb

@@ -0,0 +1,8 @@
+class CreateBlogs < ActiveRecord::Migration
+  def change
+    create_table :blogs do |t|
+
+      t.timestamps null: false
+    end
+  end
+end

data/sample/db/migrate/20160603161819_create_pages.rb

@@ -0,0 +1,8 @@
+class CreatePages < ActiveRecord::Migration
+  def change
+    create_table :pages do |t|
+
+      t.timestamps null: false
+    end
+  end
+end

data/sample/db/migrate/20160603161833_create_comments.rb

@@ -0,0 +1,10 @@
+class CreateComments < ActiveRecord::Migration
+  def change
+    create_table :comments do |t|
+      t.integer :commentable_id
+      t.string :commentable_type
+
+      t.timestamps null: false
+    end
+  end
+end

data/sample/db/schema.rb

@@ -11,7 +11,19 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20141122002555) do
+ActiveRecord::Schema.define(version: 20160603161833) do
+
+  create_table "blogs", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "comments", force: :cascade do |t|
+    t.integer  "commentable_id",   limit: 4
+    t.string   "commentable_type", limit: 255
+    t.datetime "created_at",                   null: false
+    t.datetime "updated_at",                   null: false
+  end
 
   create_table "favorites", force: :cascade do |t|
     t.integer  "tweet_id",   limit: 4
@@ -22,6 +34,11 @@ ActiveRecord::Schema.define(version: 20141122002555) do
 
   add_index "favorites", ["tweet_id"], name: "index_favorites_on_tweet_id", using: :btree
 
+  create_table "pages", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
   create_table "tweets", force: :cascade do |t|
     t.integer  "in_reply_to_tweet_id", limit: 4
     t.integer  "user_id",              limit: 4

data/test/cases/associations/eager_count_test.rb

@@ -5,13 +5,15 @@ class EagerCountTest < ActiveRecord::CountLoader::TestCase
     tweets_count.times do |i|
       tweet = Tweet.create
       i.times do |j|
-        Favorite.create(tweet: tweet, user_id: j + 1)
+        favorite = Favorite.create(tweet: tweet, user_id: j + 1)
+        Notification.create(notifiable: favorite)
+        Notification.create(notifiable: tweet)
       end
     end
   end
 
   def teardown
-    if Tweet.has_reflection?(:favs_count)
+    if has_reflection?(Tweet, :favs_count)
       Tweet.reflections.delete('favs_count')
     end
 
@@ -23,9 +25,9 @@ class EagerCountTest < ActiveRecord::CountLoader::TestCase
   end
 
   def test_eager_count_defines_count_loader
-    assert_equal(false, Tweet.has_reflection?(:favs_count))
+    assert_equal(false, has_reflection?(Tweet, :favs_count))
     Tweet.eager_count(:favs).map(&:favs_count)
-    assert_equal(true, Tweet.has_reflection?(:favs_count))
+    assert_equal(true, has_reflection?(Tweet, :favs_count))
   end
 
   def test_eager_count_has_many_with_count_loader_does_not_execute_n_1_queries
@@ -47,4 +49,11 @@ class EagerCountTest < ActiveRecord::CountLoader::TestCase
     assert_equal(expected, Tweet.order(id: :asc).eager_count(:my_favs).map { |t| t.my_favs.count })
     assert_equal(expected, Tweet.order(id: :asc).eager_count(:my_favs).map(&:my_favs_count))
   end
+
+  def test_polymorphic_eager_count
+    skip 'eager_count of polymorphic is not implemented yet'
+    expected = Tweet.all.map { |t| t.notifications.count }
+    assert_equal(expected, Tweet.eager_count(:notifications).map(&:notifications_count))
+    assert_equal(expected, Tweet.eager_count(:notifications).map { |t| t.notifications.count })
+  end
 end

data/test/cases/associations/precount_test.rb

@@ -5,13 +5,15 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
     tweets_count.times do |i|
       tweet = Tweet.create
       i.times do |j|
-        Favorite.create(tweet: tweet, user_id: j + 1)
+        favorite = Favorite.create(tweet: tweet, user_id: j + 1)
+        Notification.create(notifiable: favorite)
+        Notification.create(notifiable: tweet)
       end
     end
   end
 
   def teardown
-    if Tweet.has_reflection?(:favs_count)
+    if has_reflection?(Tweet, :favs_count)
       Tweet.reflections.delete('favs_count')
     end
 
@@ -23,9 +25,9 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
   end
 
   def test_precount_defines_count_loader
-    assert_equal(false, Tweet.has_reflection?(:favs_count))
+    assert_equal(false, has_reflection?(Tweet, :favs_count))
     Tweet.precount(:favs).map(&:favs_count)
-    assert_equal(true, Tweet.has_reflection?(:favs_count))
+    assert_equal(true, has_reflection?(Tweet, :favs_count))
   end
 
   def test_precount_has_many_with_count_loader_does_not_execute_n_1_queries
@@ -47,4 +49,11 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
     assert_equal(expected, Tweet.precount(:my_favs).map { |t| t.my_favs.count })
     assert_equal(expected, Tweet.precount(:my_favs).map(&:my_favs_count))
   end
+
+  def test_polymorphic_precount
+    expected = Tweet.all.map { |t| t.notifications.count }
+    assert_equal(expected, Tweet.precount(:notifications).map(&:notifications_count))
+    assert_equal(expected, Tweet.precount(:notifications).map { |t| t.notifications.count })
+    assert_equal(expected, Tweet.all.map(&:notifications_count))
+  end
 end

data/test/cases/helper.rb

@@ -4,4 +4,6 @@ require 'support/autorun'
 require 'cases/test_case'
 
 require 'models/favorite'
+require 'models/notification'
 require 'models/tweet'
+require 'models/user'

data/test/cases/test_case.rb

@@ -1,5 +1,11 @@
+require 'active_record/precount/reflection_checker'
+
 module ActiveRecord::CountLoader
   class TestCase < Minitest::Test
+    def has_reflection?(klass, name)
+      ActiveRecord::Precount::ReflectionChecker.has_reflection?(klass, name)
+    end
+
     def teardown
       SQLCounter.clear_log
     end

data/test/models/favorite.rb

@@ -1,3 +1,4 @@
 class Favorite < ActiveRecord::Base
   belongs_to :tweet, counter_cache: :favorites_count_cache
+  has_many :notifications, as: :notifiable, foreign_key: :notifiable_id
 end

data/test/models/notification.rb

@@ -0,0 +1,3 @@
+class Notification < ActiveRecord::Base
+  belongs_to :notifiable, polymorphic: true
+end

data/test/models/tweet.rb

@@ -3,4 +3,5 @@ class Tweet < ActiveRecord::Base
   has_many :favs, class_name: 'Favorite'
   has_many :my_favorites, -> { where(user_id: 1) }, class_name: 'Favorite', count_loader: true
   has_many :my_favs, -> { where(user_id: 1) }, class_name: 'Favorite'
+  has_many :notifications, as: :notifiable, foreign_key: :notifiable_id
 end

data/test/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  has_many :tweets
+  has_many :favorites, through: :tweets
+end

data/test/schema/schema.rb

@@ -6,6 +6,13 @@ ActiveRecord::Schema.define do
   end
   add_index :favorites, :tweet_id
 
+  create_table :notifications, force: true do |t|
+    t.integer  :notifiable_id
+    t.string   :notifiable_type
+    t.timestamps null: false
+  end
+  add_index :notifications, [:notifiable_id, :notifiable_type]
+
   create_table :tweets, force: true do |t|
     t.integer  :in_reply_to_tweet_id
     t.integer  :user_id
@@ -13,4 +20,8 @@ ActiveRecord::Schema.define do
     t.timestamps null: false
   end
   add_index :tweets, :in_reply_to_tweet_id
+
+  create_table :users, force: true do |t|
+    t.timestamps null: false
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-precount
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -193,6 +193,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -204,12 +205,13 @@ files:
 - ci/Gemfile.activerecord-5.0.x
 - ci/travis.rb
 - lib/active_record/precount.rb
-- lib/active_record/precount/association_reflection_extension.rb
 - lib/active_record/precount/base_extension.rb
 - lib/active_record/precount/collection_proxy_extension.rb
+- lib/active_record/precount/count_loader_builder.rb
 - lib/active_record/precount/has_many_extension.rb
 - lib/active_record/precount/join_dependency_extension.rb
 - lib/active_record/precount/preloader_extension.rb
+- lib/active_record/precount/reflection_checker.rb
 - lib/active_record/precount/reflection_extension.rb
 - lib/active_record/precount/relation_extension.rb
 - lib/active_record/precount/version.rb
@@ -226,8 +228,11 @@ files:
 - sample/app/helpers/application_helper.rb
 - sample/app/mailers/.keep
 - sample/app/models/.keep
+- sample/app/models/blog.rb
+- sample/app/models/comment.rb
 - sample/app/models/concerns/.keep
 - sample/app/models/favorite.rb
+- sample/app/models/page.rb
 - sample/app/models/tweet.rb
 - sample/app/models/user.rb
 - sample/app/views/application/index.html.erb
@@ -258,6 +263,9 @@ files:
 - sample/db/migrate/20141122002518_create_tweets.rb
 - sample/db/migrate/20141122002548_create_favorites.rb
 - sample/db/migrate/20141122002555_create_users.rb
+- sample/db/migrate/20160603161811_create_blogs.rb
+- sample/db/migrate/20160603161819_create_pages.rb
+- sample/db/migrate/20160603161833_create_comments.rb
 - sample/db/schema.rb
 - sample/db/seeds.rb
 - sample/lib/assets/.keep
@@ -281,7 +289,9 @@ files:
 - test/config.example.yml
 - test/config.rb
 - test/models/favorite.rb
+- test/models/notification.rb
 - test/models/tweet.rb
+- test/models/user.rb
 - test/schema/schema.rb
 - test/support/autorun.rb
 - test/support/config.rb

data/lib/active_record/precount/association_reflection_extension.rb

@@ -1,45 +0,0 @@
-module ActiveRecord
-  module Associations
-    class CountLoader < SingularAssociation
-      # Not preloaded behaviour of count_loader association
-      # When this method is called, it will be N+1 query
-      def load_target
-        count_target = reflection.name_without_count.to_sym
-        @target = owner.association(count_target).count
-
-        loaded! unless loaded?
-        target
-      rescue ActiveRecord::RecordNotFound
-        reset
-      end
-    end
-  end
-
-  module Precount
-    module AssociationReflectionExtension
-      def klass
-        case macro
-        when :count_loader
-          @klass ||= active_record.send(:compute_type, options[:class_name] || name_without_count.singularize.classify)
-        else
-          super
-        end
-      end
-
-      def name_without_count
-        name.to_s.sub(/_count$/, "")
-      end
-
-      def association_class
-        case macro
-        when :count_loader
-          ActiveRecord::Associations::CountLoader
-        else
-          super
-        end
-      end
-    end
-  end
-
-  Reflection::AssociationReflection.prepend(Precount::AssociationReflectionExtension)
-end