dase 3.2.1

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
+.idea

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Vladimir Yartsev
+
+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,98 @@
+# 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:
+
+```
+  Author.find_each do |author|
+    cnt = author.books.where(year: 1992).count
+    puts "#{author.name} has published #{cnt} books in 1992"
+  end
+```
+
+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                      
+```
+
+The Dase gem provides a similar solution for the efficient counting of associated records:
+```
+  authors = Author.includes_count_of(:books)  # => will cause only 2 queries
+  authors.first.books_count                   
+```
+
+
+## Installation
+
+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,
+which it has been tested with.
+E.g. the latest 3.2.* version of Dase will play nicely with the latest 3.2.* version of Active Record.
+Since it's a sort of a "hack", make sure you specified the version number for "dase" gem in your Gemfile.
+
+## Usage
+
+### Basic usage:
+
+```
+  Author.includes_count_of(:books).find_each do |author|
+    puts "#{author.name} has #{author.books_count} books published"
+  end
+```
+
+### Advanced usage:
+
+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})
+```
+
+### Known problems
+
+1. Dase doesn't support :through option on associations
+2. You can't put includes_count_of calls into a scope declaration, like this:
+
+```
+class Author
+   scope :with_counters, lambda {
+      includes_count_of(:books)    # this will not work!!!
+   }
+end
+```
+
+## How it works
+
+The equivalent code would look something like this:
+```
+  counters_hash = Book.count(:group => :author_id)
+  Author.find_each do |author|
+    puts "#{author.name} has #{counters_hash[author.id] || 0} books published"
+  end
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+end
+
+task :default => :test

data/dase.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dase/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "dase"
+  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.add_runtime_dependency "activerecord", "~> 3.2.0"
+  gem.add_runtime_dependency "activesupport", "~> 3.2.0"
+  gem.add_development_dependency 'shoulda'
+  gem.add_development_dependency 'sqlite3', '~> 1.3.3'
+  gem.add_development_dependency 'debugger'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/dase/mp_active_record_base.rb

@@ -0,0 +1,38 @@
+# Monkey-patching ActiveRecord::Base to add xxx_count methods to it
+
+module Dase
+  module ARBaseInstanceMethods
+    def set_dase_counter(name, value)
+      @dase_counters ||= {}
+      @dase_counters[name] = value
+    end
+
+    def get_dase_counter(name)
+      @dase_counters[name]
+    end
+
+    def respond_to?(*args)
+      @dase_counters && @dase_counters.has_key?(args.first.to_sym) || super
+    end
+
+    def method_missing(name, *args)
+      if @dase_counters and @dase_counters.has_key?(name.to_sym)
+        get_dase_counter(name, *args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def self.included(klass)
+      class << klass
+        delegate :includes_count_of, :to => :scoped
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include Dase::ARBaseInstanceMethods
+end

data/lib/dase/mp_active_record_relation.rb

@@ -0,0 +1,40 @@
+module Dase
+  module ARRelationInstanceMethods
+    attr_accessor :dase_values
+
+    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)
+      return self if args.empty?
+      relation = clone
+      relation.dase_values ||= {}
+      args.each { |a| relation.dase_values[a] = options}
+      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
+        end
+        @has_dase_counters = true
+      end
+    end
+  end
+end
+
+
+ActiveRecord::Relation.class_eval do
+  include Dase::ARRelationInstanceMethods
+
+  private
+
+  alias_method :exec_queries_before_dase, :exec_queries
+
+  def exec_queries
+    exec_queries_before_dase # original method from ActiveRecord
+    attach_dase_counters_to_records
+    @records
+  end
+end

data/lib/dase/preloader.rb

@@ -0,0 +1,35 @@
+module Dase
+  class Preloader < ::ActiveRecord::Associations::Preloader
+
+    # custom preloaders for different association types
+    class HasMany < ::ActiveRecord::Associations::Preloader::HasMany
+      include Dase::PreloaderMethods
+    end
+    class HasAndBelongsToMany < ::ActiveRecord::Associations::Preloader::HasAndBelongsToMany
+      include Dase::PreloaderMethods
+    end
+
+    # Not implemented yet
+    #class HasManyThrough < ::ActiveRecord::Associations::Preloader::HasManyThrough
+    #  include Dase::PreloaderMethods
+    #end
+
+    # an overloaded version of ActiveRecord::Associations::Preloader's preloader_for
+    # which returns a class of a custom preloader for a given association
+    def preloader_for(reflection)
+      case reflection.macro
+        when :has_many
+          if reflection.options[:through]
+            raise NotImplementedError, "The support for HasManyThrough associations is not implemented yet"
+          else
+            HasMany
+          end
+        when :has_one, :belongs_to
+          raise ArgumentError, "You can't use includes_count_of with a #{reflection.macro} association"
+        when :has_and_belongs_to_many
+          HasAndBelongsToMany
+      end
+    end
+  end
+
+end

data/lib/dase/preloader_methods.rb

@@ -0,0 +1,15 @@
+module Dase
+  module PreloaderMethods
+    def preload
+      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}"
+      counters_hash = records_for(ids).count(group: fk)
+      owners.each do |owner|
+        value = counters_hash[owner[pk]] || 0 # 0 is "default count", when no records found
+        owner.set_dase_counter(counter_name, value)
+      end
+    end
+  end
+end

data/lib/dase/version.rb

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

data/lib/dase.rb

@@ -0,0 +1,10 @@
+require "dase/version"
+require "dase/preloader_methods"
+require "dase/preloader"
+require "dase/mp_active_record_base"
+require "dase/mp_active_record_relation"
+
+module Dase
+  # take a look at mp_active_record_* files
+  # (there we monkey-patch Active Record)
+end

data/test/fixtures/author.rb

@@ -0,0 +1,9 @@
+class Author < ActiveRecord::Base
+  attr_accessible :name
+
+  has_many :books
+  has_many :old_books, :class_name => "Book", :conditions => {:year => 1990}
+
+  has_many :quotes, :through => :books
+
+end

data/test/fixtures/authors.yml

@@ -0,0 +1,20 @@
+joe:
+  name      : Joe
+  id        : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+  # has 3 books: two old (year 1990) and one new (year 2012) book
+
+bobby:
+  name      : Bobby
+  id        : 2
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+  # has 1 old book (year 1990)
+
+teddy:
+  name      : Teddy
+  id        : 3
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+  # has no books at all

data/test/fixtures/book.rb

@@ -0,0 +1,7 @@
+class Book < ActiveRecord::Base
+  attr_accessible :title, :year
+
+  belongs_to :author
+  has_many :quotes
+
+end

data/test/fixtures/books.yml

@@ -0,0 +1,34 @@
+# Joe's books
+first:
+  id        : 1
+  year      : 1990
+  title     : First book
+  author_id : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+
+second:
+  id        : 2
+  year      : 1990
+  title     : Second book
+  author_id : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+
+third:
+  id        : 3
+  year      : 2012
+  title     : Third book
+  author_id : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+
+
+# Bobby's book
+fourth:
+  id        : 4
+  year      : 1990
+  title     : Fourth book
+  author_id : 2
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00

data/test/fixtures/quote.rb

@@ -0,0 +1,4 @@
+class Quote < ActiveRecord::Base
+  belongs_to :book
+
+end

data/test/fixtures/quotes.yml

@@ -0,0 +1,16 @@
+# Joe's quotation
+first:
+  id: 1
+  book_id: 1
+  snippet: "To be or not to be, that is the question"
+
+# Bobby's quotations
+second:
+  id: 2
+  book_id: 4
+  snippet: "No matter how much cats fight, there always seem to be plenty of kittens"
+
+third:
+  id: 3
+  book_id: 4
+  snippet: "I am fond of pigs. Dogs look up to us. Cats look down on us. Pigs treat us as equals."

data/test/fixtures/schema.rb

@@ -0,0 +1,22 @@
+ActiveRecord::Schema.define do
+
+  create_table "authors", :force => true do |t|
+    t.string "name"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "books", :force => true do |t|
+    t.integer "year"
+    t.string "title"
+    t.integer "author_id"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "quotes", :force => true do |t|
+    t.string "snippet"
+    t.integer "book_id"
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,30 @@
+# borrowed from https://github.com/ernie/meta_where/blob/master/test/helper.rb
+# with slight modifications
+require "rubygems"
+require "bundler"
+Bundler.setup
+require 'test/unit'
+require 'shoulda'
+require 'active_record'
+require 'active_record/fixtures'
+require 'dase'
+
+FIXTURES_PATH = File.join(File.dirname(__FILE__), 'fixtures')
+
+ActiveRecord::Base.establish_connection(
+    :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3',
+    :database => ':memory:'
+)
+
+dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+dep.autoload_paths.unshift FIXTURES_PATH
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  load File.join(FIXTURES_PATH, 'schema.rb')
+end
+
+ActiveRecord::Fixtures.create_fixtures(FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+
+class Test::Unit::TestCase
+end

data/test/test_dase.rb

@@ -0,0 +1,52 @@
+require 'helper'
+
+class TestBase < Test::Unit::TestCase
+
+  def compare_counts(traditional, dase, true_counts)
+    assert_equal true_counts, traditional, "traditional counting failed - fixtures not loaded"
+    assert_equal true_counts, dase, "dase countings failed"
+  end
+
+  context "includes_count_of" do
+    setup do
+      @bobby, @joe, @teddy = Author.order(:name).all
+    end
+
+    should "count books" do
+      traditional_counts = Author.order(:name).map { |a| a.books.count }
+      dase_counts = Author.includes_count_of(:books).order(:name).map { |a| a.books_count }
+      # the order is: Bobby, Joe, Teddy - due to order(:name)
+      true_counts = [1, 3, 0] # see books.yml
+      compare_counts(traditional_counts, dase_counts, true_counts)
+    end
+
+    should "respond_to the counter method" do
+      assert_equal true, Author.includes_count_of(:books).first.respond_to?(:books_count), "doesn't respond'"
+    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 }
+      # the order is: Bobby, Joe, Teddy - due to order(:name)
+      true_counts = [1, 2, 0] # see books.yml
+      compare_counts(traditional_counts, dase_counts, true_counts)
+    end
+
+    should "count books for year 1990" do
+      traditional_counts = Author.order(:name).map { |a| a.books.where(year: 1990).count }
+      dase_counts = Author.includes_count_of(:books, :conditions => {:year => 1990}).order(:name).map { |a| a.books_count }
+      # the order is: Bobby, Joe, Teddy - due to order(:name)
+      true_counts = [1, 2, 0] # see books.yml
+      compare_counts(traditional_counts, dase_counts, true_counts)
+    end
+
+    # Not yet implemented
+    #should "count quotations" do
+    #  traditional_counts = Author.order(:name).map { |a| a.quotes.count }
+    #  dase_counts = Author.order(:name).includes_count_of(:quotes).map { |a| a.quotes_count }
+    #  # the order is: Bobby, Joe, Teddy - due to order(:name)
+    #  true_counts = [2, 1, 0] # see quotes.yml
+    #  compare_counts(traditional_counts, dase_counts, true_counts)
+    #end
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: dase
+version: !ruby/object:Gem::Version
+  version: 3.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Vladimir Yartsev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70291652811140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70291652811140
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70291652810620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70291652810620
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70291652810220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70291652810220
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70291652808960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :development
+  prerelease: false
+  version_requirements: *70291652808960
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: &70291652808360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70291652808360
+description: A solution for N+1 querying problem in Active Record associated records
+  counting
+email:
+- vovayartsev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dase.gemspec
+- lib/dase.rb
+- lib/dase/mp_active_record_base.rb
+- lib/dase/mp_active_record_relation.rb
+- lib/dase/preloader.rb
+- lib/dase/preloader_methods.rb
+- lib/dase/version.rb
+- test/fixtures/author.rb
+- test/fixtures/authors.yml
+- test/fixtures/book.rb
+- test/fixtures/books.yml
+- test/fixtures/quote.rb
+- test/fixtures/quotes.yml
+- test/fixtures/schema.rb
+- test/helper.rb
+- test/test_dase.rb
+homepage: https://github.com/vovayartsev
+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: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Really fast associated records counting
+test_files:
+- test/fixtures/author.rb
+- test/fixtures/authors.yml
+- test/fixtures/book.rb
+- test/fixtures/books.yml
+- test/fixtures/quote.rb
+- test/fixtures/quotes.yml
+- test/fixtures/schema.rb
+- test/helper.rb
+- test/test_dase.rb