includes-count 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in includes-count.gemspec
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+Includes Count Gem
+==================
+
+Tested with ActiveRecord version 3.1.3

data/Rakefile

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

data/includes-count.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "includes-count/version"
+
+Gem::Specification.new do |s|
+  s.name        = "includes-count"
+  s.version     = IncludesCount::VERSION
+  s.authors     = ["Santiago Palladino"]
+  s.email       = ["spalladino@manas.com.ar"]
+  s.homepage    = ""
+  s.summary     = %q{Adds includes_count method to active record queries}
+  s.description = %q{The includes_count method executes a SQL count on an association to retrieve its number of records, optionally filtered by a set of conditions.}
+
+  s.rubyforge_project = "includes-count"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "activerecord"
+end

data/lib/includes-count.rb

@@ -0,0 +1,137 @@
+require "includes-count/version"
+
+module ActiveRecord
+  
+  module Associations
+    
+    class CountPreloader < Preloader
+            
+      class Count < ActiveRecord::Associations::Preloader::HasOne
+
+        def initialize(klass, owners, reflection, preload_options)
+          super
+          @preload_options[:select] ||= "#{table.name}.#{association_key_name}, COUNT(id) AS #{count_name}"
+        end
+
+        def count_name
+          preload_options[:count_name].try(:to_s) || "#{reflection.name}_count"
+        end
+
+        def preload
+          associated_records_by_owner.each do |owner, associated_records|
+            owner[count_name] ||= 0
+            owner[count_name] += associated_records.map{|r| r[count_name] || 0}.sum
+          end
+        end
+
+        def build_scope
+          super.group(association_key)
+        end
+
+      end
+      
+      class CountHasMany < Count
+      end
+      
+      class CountHasManyThrough < Count
+        include ThroughAssociation
+        
+        def associated_records_by_owner          
+          through_records = through_records_by_owner
+
+          ActiveRecord::Associations::CountPreloader.new(
+            through_records.values.flatten,
+            source_reflection.name, options.merge(@preload_options)
+          ).run
+
+          through_records
+          
+        end
+         
+        def through_records_by_owner
+          ActiveRecord::Associations::Preloader.new(
+            owners, through_reflection.name,
+            through_options
+          ).run
+
+          Hash[owners.map do |owner|
+            through_records = Array.wrap(owner.send(through_reflection.name))
+
+            # Dont cache the association - we would only be caching a subset
+            if reflection.options[:source_type] && through_reflection.collection?
+              owner.association(through_reflection.name).reset
+            end
+
+            [owner, through_records]
+          end]
+        end
+
+        def through_options
+          through_options = {}
+
+          if options[:source_type]
+            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+          else
+            if options[:conditions]
+              through_options[:include]    = options[:include] || options[:source]
+              through_options[:conditions] = options[:conditions]
+            end
+
+            through_options[:order] = options[:order]
+          end
+          
+          if @preload_options[:through_options]
+            through_preload_options = @preload_options[:through_options][through_reflection.name.to_sym] || {}
+            through_options.merge!(through_preload_options)
+          end
+        
+          through_options
+        end
+        
+      end
+      
+      def preloader_for(reflection)
+        case reflection.macro 
+          when :has_many
+            reflection.options[:through] ? CountHasManyThrough : CountHasMany
+          else
+            raise "unsupported association kind #{reflection.macro}"
+        end
+      end
+      
+    end
+  
+  end
+  
+  class Relation
+  
+    attr_accessor :includes_counts_values
+  
+    def includes_count(*args)
+      args.reject! {|a| a.blank? }
+
+      return self if args.empty?
+
+      relation = clone
+      (relation.includes_counts_values ||= []) << args
+      relation
+    end
+  
+    def to_a_with_includes_count
+      return @records if loaded?
+      
+      to_a_without_includes_count
+      
+      (includes_counts_values || []).each do |association_with_opts|
+        association, opts = association_with_opts
+        ActiveRecord::Associations::CountPreloader.new(@records, [association], opts).run
+      end
+      
+      @records
+    end
+
+    alias_method_chain :to_a, :includes_count
+
+  end
+  
+end

data/lib/includes-count/version.rb

@@ -0,0 +1,3 @@
+module IncludesCount
+  VERSION = "0.1"
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: includes-count
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Santiago Palladino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70110664755620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70110664755620
+description: The includes_count method executes a SQL count on an association to retrieve
+  its number of records, optionally filtered by a set of conditions.
+email:
+- spalladino@manas.com.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- includes-count.gemspec
+- lib/includes-count.rb
+- lib/includes-count/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: includes-count
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Adds includes_count method to active record queries
+test_files: []