activerecord-count_loader 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b18fe399d79f7718389245f46d6c8344489c7797
+  data.tar.gz: 41ce60a38bb937a114c0edcff1b79e183e1d94d5
+SHA512:
+  metadata.gz: fab66eaef7777f10c7ec1778ee58f1cc2588187d8194bcb4698b6c458452e7822fd9e5fd4c47dd054f2410dde1f234788d77f292d44e32777f69516ab4b63cf7
+  data.tar.gz: 7ae932c1f0ef58173a8f679863a6292e3a8f9195445476671857b29656d51b2e85aa20edaaceb6f2e45551b775ad1f208d3c683b7352fc42d8741e75dbd12244

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.sqlite3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-count_loader.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Takashi Kokubun
+
+MIT License
+
+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,72 @@
+# ActiveRecord::CountLoader
+
+N+1 count query killer for ActiveRecord.  
+ActiveRecord::CountLoader allows you to cache count of associated records by eager loading.
+
+## Why ActiveRecord::CountLoader?
+Rails provides a way to resolve N+1 count query, which is [belongs\_to's counter\_cache option](http://guides.rubyonrails.org/association_basics.html#counter-cache).  
+It requires a column to cache the count. But adding a column just for count cache is overkill.  
+  
+Thus this plugin enables you to preload counts in the same way as `has_many` and `belongs_to`.  
+`count_loader` is an ActiveRecord's association, which is preloadable by `preload` or `includes`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-count_loader'
+```
+
+## Usage
+
+### Enable count\_loader option
+First, enable your has\_many association's count\_loader option.
+
+```diff
+ class Tweet
+-  has_many :favorites
++  has_many :favorites, count_loader: true
+ end
+```
+
+The option defines an additional association whose name is `favorites_count`.  
+Its association type is not an ordinary one (i.e. `has_many`, `belongs_to`) but `count_loader`.
+
+### Preload the association
+This association works well by default.
+
+```rb
+@tweets = Tweet.all
+@tweets.each do |tweet|
+  p tweets.favorites_count # same as tweets.favorites.count
+end
+```
+
+You can eagerly load `count_loader` association by `includes` or `preload`.
+
+```rb
+@tweets = Tweet.preload(:favorites_count)
+@tweets.each do |tweet|
+  p tweets.favorites_count # this line doesn't execute an additional query
+end
+```
+
+Since it is association, you can preload nested `count_loader` association.
+
+```rb
+@users = User.preload(tweets: :favorites_count).all
+@users.each do |user|
+  user.tweets.each do |tweet|
+    p tweet.favorites_count # this line doesn't execute an additional query
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/k0kubun/activerecord-count_loader/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activerecord-count_loader.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/count_loader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-count_loader"
+  spec.version       = ActiveRecord::CountLoader::VERSION
+  spec.authors       = ["Takashi Kokubun"]
+  spec.email         = ["takashikkbn@gmail.com"]
+  spec.summary       = %q{N+1 count query killer for ActiveRecord}
+  spec.description   = %q{N+1 count query killer for ActiveRecord}
+  spec.homepage      = "https://github.com/k0kubun/activerecord-count_loader"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 1.9.2"
+  spec.add_runtime_dependency "activerecord", ">= 3.2.0"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "factory_girl", "~> 4.2.0"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "pry"
+end

data/lib/active_record/associations/builder/count_loader.rb

@@ -0,0 +1,13 @@
+module ActiveRecord::Associations::Builder
+  class CountLoader < SingularAssociation
+    self.valid_options = [:class_name, :foreign_key]
+
+    def macro
+      :count_loader
+    end
+
+    def self.valid_dependent_options
+      []
+    end
+  end
+end

data/lib/active_record/associations/count_loader.rb

@@ -0,0 +1,17 @@
+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
+end

data/lib/active_record/associations/preloader/count_loader.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class CountLoader < SingularAssociation
+        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|
+            count = associated_records.count
+
+            association = owner.association(reflection.name)
+            association.target = count
+          end
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
+            key = record
+            [record, key]
+          }
+        end
+
+        def query_scope(ids)
+          scope.where(association_key.in(ids)).pluck(association_key_name)
+        end
+      end
+
+      private
+
+      def preloader_for_with_count_loader(reflection, owners, rhs_klass)
+        preloader = preloader_for_without_count_loader(reflection, owners, rhs_klass)
+        return preloader if preloader
+
+        case reflection.macro
+        when :count_loader
+          CountLoader
+        end
+      end
+      alias_method_chain :preloader_for, :count_loader
+    end
+  end
+end

data/lib/active_record/count_loader/extend.rb

@@ -0,0 +1,8 @@
+ActiveSupport.on_load(:active_record) do
+  module ActiveRecord
+    Reflection.prepend(CountLoader::ReflectionExtension)
+    Associations::JoinDependency.prepend(CountLoader::JoinDependencyExtension)
+    Associations::Builder::HasMany.prepend(CountLoader::Builder::HasManyExtension)
+    Reflection::AssociationReflection.prepend(CountLoader::AssociationReflectionExtension)
+  end
+end

data/lib/active_record/count_loader/has_many_extension.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module CountLoader
+    module Builder
+      module HasManyExtension
+        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, nil, valid_options)
+          Reflection.add_reflection(model, name_with_count, reflection)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/count_loader/join_dependency_extension.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  # This imitates EagerLoadPolymorphicError
+  class EagerLoadCountLoaderError < ActiveRecordError
+    def initialize(reflection)
+      super("Cannot eagerly load the count_loader association #{reflection.name.inspect}")
+    end
+  end
+
+  module CountLoader
+    module JoinDependencyExtension
+      def build(associations, base_klass)
+        associations.map do |name, right|
+          reflection = find_reflection base_klass, name
+          if reflection.macro == :count_loader
+            raise EagerLoadCountLoaderError.new(reflection)
+          end
+        end
+
+        super(associations, base_klass)
+      end
+    end
+  end
+end

data/lib/active_record/count_loader/reflection_extension.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module CountLoader
+    module ReflectionExtension
+      def self.prepended(base)
+        class << base
+          prepend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def create(macro, name, scope, options, ar)
+          case macro
+          when :count_loader
+            Reflection::AssociationReflection.new(macro, name, scope, options, ar)
+          else
+            super(macro, name, scope, options, ar)
+          end
+        end
+      end
+    end
+
+    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
+end

data/lib/active_record/count_loader/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module CountLoader
+    VERSION = "0.2.0"
+  end
+end

data/lib/activerecord-count_loader.rb

@@ -0,0 +1,11 @@
+require "active_record"
+require "active_support/lazy_load_hooks"
+
+require "active_record/associations/count_loader"
+require "active_record/associations/builder/count_loader"
+require "active_record/associations/preloader/count_loader"
+
+require "active_record/count_loader/has_many_extension"
+require "active_record/count_loader/join_dependency_extension"
+require "active_record/count_loader/reflection_extension"
+require "active_record/count_loader/extend"

data/sample/.gitignore

@@ -0,0 +1,16 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/sample/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'rails', '4.1.5'
+gem 'mysql2'
+gem 'sass-rails', '~> 4.0.3'
+gem 'uglifier', '>= 1.3.0'
+gem 'coffee-rails', '~> 4.0.0'
+gem 'jquery-rails'
+gem 'turbolinks'
+gem 'jbuilder', '~> 2.0'
+gem 'sdoc', '~> 0.4.0', group: :doc
+
+gem 'activerecord-count_loader', path: '..'
+
+group :development do
+  gem 'pry'
+  gem 'spring'
+  gem 'silencer'
+end

data/sample/README.md

@@ -0,0 +1,6 @@
+# sample
+
+```bash
+$ bundle exec rake db:create db:migrate
+$ bundle exec rake db:seed
+```

data/sample/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/sample/app/assets/javascripts/application.js

@@ -0,0 +1,16 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require jquery
+//= require jquery_ujs
+//= require turbolinks
+//= require_tree .