dase 3.2.1 → 3.2.2

data/README.md

@@ -1,29 +1,16 @@
 # Dase
 
-The gem is named by the german mathematician [Johann Dase](http://en.wikipedia.org/wiki/Zacharias_Dase),
-who was a mental calculator - he could count and multiply numbers very quickly. Dase gem adds extra speed 
-to Active Record whenever you need to calculate the number of associated records.
-
-Here's an example of the code that will cause N + 1 queries:
+## Overview
 
-```
-  Author.find_each do |author|
-    cnt = author.books.where(year: 1992).count
-    puts "#{author.name} has published #{cnt} books in 1992"
-  end
-```
+Dase gem provides 'includes_count_of' method on a relation, which works similar to ActiveRecord's 'includes' method.
 
-Active Record has a built-in solution for efficient fetching of
-associated records - see [Rails Guides](http://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations)
-```
-  authors = Author.includes(:books)  # => will cause only 2 queries
-  authors.first                      
-```
+![Dase example](https://vovayartsev-home.s3.amazonaws.com/dase-mockup.png)
 
-The Dase gem provides a similar solution for the efficient counting of associated records:
+Calling 'includes_count_of(:articles)' on a relation object adds 'articles_count' method to each of the authors:
 ```
-  authors = Author.includes_count_of(:books)  # => will cause only 2 queries
-  authors.first.books_count                   
+  authors = Author.includes(:publisher).includes_count_of(:articles, :conditions => {:year => 2012})  
+  authors.first.name             # => 'Billy'                
+  authors.first.articles_count   # => 2                
 ```
 
 
@@ -33,14 +20,6 @@ Add this line to your application's Gemfile:
 
     gem 'dase', "~> 3.2.0"
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install dase
-
 ### Note on version numbers
 
 Dase version number correlates with the Active Record's versions number,
@@ -53,8 +32,8 @@ Since it's a sort of a "hack", make sure you specified the version number for "d
 ### Basic usage:
 
 ```
-  Author.includes_count_of(:books).find_each do |author|
-    puts "#{author.name} has #{author.books_count} books published"
+  Author.includes_count_of(:articles).find_each do |author|
+    puts "#{author.name} has #{author.articles_count} articles published"
   end
 ```
 
@@ -63,9 +42,10 @@ Since it's a sort of a "hack", make sure you specified the version number for "d
 You can specify a hash of options which will be passed to the underlying finder 
 which retrieves the association. Valid keys are: :conditions, :group, :having, :joins, :include
 ```
-Author.includes_count_of(:books, :conditions => {:year => 1990})
+Author.includes_count_of(:articles, :conditions => {:year => 2012})
 ```
 
+
 ### Known problems
 
 1. Dase doesn't support :through option on associations
@@ -74,21 +54,29 @@ Author.includes_count_of(:books, :conditions => {:year => 1990})
 ```
 class Author
    scope :with_counters, lambda {
-      includes_count_of(:books)    # this will not work!!!
+      includes_count_of(:articles)    # this will not work!!!
    }
 end
 ```
 
 ## How it works
 
-The equivalent code would look something like this:
+Here's a pseudo-code that gives an idea on how it works internally
 ```
-  counters_hash = Book.count(:group => :author_id)
+  counters_hash = Article.where(:year => 2012).count(:group => :author_id)
   Author.find_each do |author|
-    puts "#{author.name} has #{counters_hash[author.id] || 0} books published"
+    puts "#{author.name} has #{counters_hash[author.id] || 0} articles published"
   end
 ```
 
+
+
+
+## Name origin
+
+The gem is named by the german mathematician [Johann Dase](http://en.wikipedia.org/wiki/Zacharias_Dase),
+who was a mental calculator - he could count and multiply numbers very quickly. 
+
 ## Contributing
 
 1. Fork it

data/dase.gemspec

@@ -8,9 +8,11 @@ Gem::Specification.new do |gem|
   gem.version       = Dase::VERSION
   gem.authors       = ["Vladimir Yartsev"]
   gem.email         = ["vovayartsev@gmail.com"]
-  gem.description   = %q{A solution for N+1 querying problem in Active Record associated records counting}
-  gem.summary       = %q{Really fast associated records counting}
-  gem.homepage      = "https://github.com/vovayartsev"
+  gem.description   = %q{Dase gem creates includes_count_of method in ActiveRecord::Relation
+                         to count associated records efficiently. See examples at https://github.com/vovayartsev/dase
+                      }
+  gem.summary       = %q{Provides includes_count_of method on ActiveRecord::Relation to count associated records efficiently}
+  gem.homepage      = "https://github.com/vovayartsev/dase"
 
   gem.add_runtime_dependency "activerecord", "~> 3.2.0"
   gem.add_runtime_dependency "activesupport", "~> 3.2.0"

data/lib/dase/mp_active_record_relation.rb

@@ -5,22 +5,42 @@ module Dase
     def includes_count_of(*args)
       args.reject! { |a| a.blank? }
       options = args.extract_options!
-      options.assert_valid_keys(:conditions, :group, :having, :limit, :offset, :joins, :include, :from, :lock)
+      options.assert_valid_keys(:as, :conditions, :group, :having, :limit, :offset, :joins, :include, :from, :lock)
       return self if args.empty?
+      if options.present? and args.many?
+        raise ArgumentError, "includes_count_of takes either multiple associations OR single association + options"
+      end
       relation = clone
       relation.dase_values ||= {}
-      args.each { |a| relation.dase_values[a] = options}
+      args.each do |arg|
+        if options[:as].present?
+          options[:association] = arg
+          relation.dase_values[options[:as].to_sym] = options
+        else
+          relation.dase_values[arg] = options
+        end
+      end
       relation
     end
 
     def attach_dase_counters_to_records
       if dase_values.present? and !@has_dase_counters
-        dase_values.each do |associations, options|
-          Dase::Preloader.new(@records, associations, options).run
+        dase_values.each do |association, options|
+          association = options.delete(:association) if options[:association]
+          Dase::Preloader.new(@records, association, options).run
         end
         @has_dase_counters = true
       end
     end
+
+    def merge(r)
+      super(r).tap do |result|
+        if r.dase_values.present?
+          result.dase_values ||= {}
+          result.dase_values.merge!(r.dase_values)
+        end
+      end
+    end
   end
 end
 

data/lib/dase/preloader_methods.rb

@@ -1,7 +1,15 @@
 module Dase
   module PreloaderMethods
+
+    def initialize(klass, owners, reflection, preload_options)
+      # grabbing our options
+      preload_options = preload_options.clone
+      @dase_counter_name = preload_options.delete(:as)
+      super(klass, owners, reflection, preload_options)
+    end
+
     def preload
-      counter_name = "#{reflection.name}_count".to_sym
+      counter_name = @dase_counter_name || "#{reflection.name}_count".to_sym
       pk = model.primary_key.to_sym
       ids = owners.map(&pk)
       fk = "#{scoped.quoted_table_name}.#{reflection.foreign_key}"
@@ -11,5 +19,6 @@ module Dase
         owner.set_dase_counter(counter_name, value)
       end
     end
+
   end
 end

data/lib/dase/version.rb

@@ -1,3 +1,3 @@
 module Dase
-  VERSION = "3.2.1"
+  VERSION = "3.2.2"
 end

data/test/fixtures/author.rb

@@ -6,4 +6,6 @@ class Author < ActiveRecord::Base
 
   has_many :quotes, :through => :books
 
+  scope :with_count_of_books, lambda { includes_count_of(:books) }
+
 end

data/test/test_dase.rb

@@ -24,6 +24,23 @@ class TestBase < Test::Unit::TestCase
       assert_equal true, Author.includes_count_of(:books).first.respond_to?(:books_count), "doesn't respond'"
     end
 
+    should "sneeze through scope definitions" do
+      assert_equal true, Author.with_count_of_books.first.respond_to?(:books_count), "doesn't respond'"
+    end
+
+    should "support :as option" do
+      assert_equal true, Author.includes_count_of(:books, :as => :my_count).first.respond_to?(:my_count), "doesn't respond'"
+    end
+
+    should "support old_books_count and new_books_count simultaneously using :as option" do
+      scope = Author.includes_count_of(:books, :conditions => {:year => 2012}, :as => :new_books_count).
+                    includes_count_of(:books, :conditions => {:year => 1990}, :as => :old_books_count)
+      dase_counts = scope.order(:name).map{ |a| [a.old_books_count, a.new_books_count] }
+      # the order is Bobby[:old, :new],  Joe[:old, :new],  Teddy[:old, :new]
+      true_counts = [[1, 0], [2, 1], [0, 0]] # see books.yml
+      assert_equal true_counts, dase_counts, "results mismatch"
+    end
+
     should "count old books" do
       traditional_counts = Author.order(:name).map { |a| a.old_books.count }
       dase_counts = Author.includes_count_of(:old_books).order(:name).map { |a| a.old_books_count }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dase
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-02 00:00:00.000000000 Z
+date: 2012-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70291652811140 !ruby/object:Gem::Requirement
+  requirement: &70318116217480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70291652811140
+  version_requirements: *70318116217480
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70291652810620 !ruby/object:Gem::Requirement
+  requirement: &70318116214540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70291652810620
+  version_requirements: *70318116214540
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70291652810220 !ruby/object:Gem::Requirement
+  requirement: &70318116213300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70291652810220
+  version_requirements: *70318116213300
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70291652808960 !ruby/object:Gem::Requirement
+  requirement: &70318116211980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.3.3
   type: :development
   prerelease: false
-  version_requirements: *70291652808960
+  version_requirements: *70318116211980
 - !ruby/object:Gem::Dependency
   name: debugger
-  requirement: &70291652808360 !ruby/object:Gem::Requirement
+  requirement: &70318116211100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,9 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70291652808360
-description: A solution for N+1 querying problem in Active Record associated records
-  counting
+  version_requirements: *70318116211100
+description: ! "Dase gem creates includes_count_of method in ActiveRecord::Relation\n
+  \                        to count associated records efficiently. See examples at
+  https://github.com/vovayartsev/dase\n                      "
 email:
 - vovayartsev@gmail.com
 executables: []
@@ -95,7 +96,7 @@ files:
 - test/fixtures/schema.rb
 - test/helper.rb
 - test/test_dase.rb
-homepage: https://github.com/vovayartsev
+homepage: https://github.com/vovayartsev/dase
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -118,7 +119,8 @@ rubyforge_project:
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Really fast associated records counting
+summary: Provides includes_count_of method on ActiveRecord::Relation to count associated
+  records efficiently
 test_files:
 - test/fixtures/author.rb
 - test/fixtures/authors.yml