dase 3.2.9 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0caefe9687496a603d4b8a1812f0a3a89320bc58
-  data.tar.gz: fe0dd23b22c989fefade0b8cd4555925083c19a3
+  metadata.gz: fa21a89c14adc39b8906ec72c7b4b4c53dfefbe2
+  data.tar.gz: 1742ddc3cfa7c83952d008ec7d3421e9946883c7
 SHA512:
-  metadata.gz: 7cd235f4fa1de0ee5ea6c4c36cbe73beeb295d3665aa1532e4ac2740ab42c9008770c3627a3df30ab17535743ce4d6e77737f5df1a04b19ed4e6cdc51847d67b
-  data.tar.gz: 02d35d30617d7805da0ebc6f9b894b31594bf40c2a0af2622ce672f20e6c0eff410052ef621abdf25dde3d10f12dc366b0253cd293fc6432a59af51fe635f3bc
+  metadata.gz: 4a3383ce22ef7a04bc1363a09b15037dd7b92417bf4a65abb12a4f7027a4895c8e7dd3d62e4cd52687acd93d3653c02a18c8301530a986d1ce2a2de80da3e5af
+  data.tar.gz: ce0941ab55f4c38e9fe21b3e559f93640d9e0b61920d3ff744158a91fa1da524ecbf17b202b7d54bba61a3728dc2f7add3519de7dd551fc2ebdf630b0042e2cc

data/dase.gemspec

@@ -15,19 +15,18 @@ Gem::Specification.new do |gem|
   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 "activesupport", "~> 3.2.0"
-  gem.add_development_dependency 'shoulda'
-  
+  gem.add_runtime_dependency "activesupport", ">= 4.0", "<= 4.2"
+
   if defined? JRUBY_VERSION
     gem.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
   else
-    gem.add_runtime_dependency "activerecord", "~> 3.2.0"
-    gem.add_development_dependency 'sqlite3', '~> 1.3.3'
+    gem.add_runtime_dependency "activerecord", ">= 4.0", "<= 4.2"
+    gem.add_development_dependency 'sqlite3', '~> 1.3'
   end
 
   # gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec-core'
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec-core', '~> 3.1'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/dase.rb

@@ -6,4 +6,11 @@ require "dase/mp_active_record"
 module Dase
   # take a look at mp_active_record files
   # (there we monkey-patch Active Record)
+
+  # Syntax definition
+  VALID_DASE_OPTIONS = [:as]
+  VALID_ASSOCIATION_OPTIONS = [:proc, :where, :group, :having, :joins, :merge, :includes, :from]
+
+  # Legacy syntax support
+  VALID_SYNONYMS = {:only => :merge, :conditions => :where}
 end

data/lib/dase/mp_active_record.rb

@@ -1,12 +1,13 @@
 module Dase
-  module ARRelationInstanceMethods
+  module RelationInstanceMethods
     def dase_values
       @dase_values ||= {}
     end
 
     def includes_count_of(*args)
       options = args.extract_options!
-      sanitize_includes_count_of_options(args, options)
+      sanitize_dase_options(args, options)
+      apply_synonyms(options)
       return self if args.empty?
       clone.tap do |relation|
         args.each do |arg|
@@ -24,8 +25,18 @@ module Dase
 
     private
 
-    def sanitize_includes_count_of_options(args, options)
-      options.assert_valid_keys(:proc, :as, :only, :conditions, :group, :having, :limit, :offset, :joins, :include, :from, :lock)
+    # legacy syntax support
+    def apply_synonyms(options)
+      VALID_SYNONYMS.each do |old, new|
+        if options.has_key?(old)
+          raise "Don't use #{old} and #{new} together" if options.has_key?(new)
+          options[new] = options.delete(old)
+        end
+      end
+    end
+
+    def sanitize_dase_options(args, options)
+      options.assert_valid_keys *(VALID_DASE_OPTIONS + VALID_ASSOCIATION_OPTIONS + VALID_SYNONYMS.keys)
       if options.present? and args.many?
         raise ArgumentError, 'includes_count_of takes either multiple associations OR single association + options'
       end
@@ -33,14 +44,14 @@ module Dase
 
     def attach_dase_counters_to_records
       (dase_values || {}).each do |_, options|
-        Dase::Preloader.new(@records, options[:association], options).run
+        Dase::Preloader.new(options).preload(@records, options[:association])
       end
     end
   end
 end
 
 ActiveRecord::Relation.class_eval do
-  include Dase::ARRelationInstanceMethods
+  include Dase::RelationInstanceMethods
 
   private
 
@@ -54,6 +65,6 @@ ActiveRecord::Relation.class_eval do
 end
 
 class << ActiveRecord::Base
-  delegate :includes_count_of, :to => :scoped
+  delegate :includes_count_of, :to => :all
 end
 

data/lib/dase/preloader.rb

@@ -7,39 +7,42 @@ module Dase
       include Dase::PreloaderMethods
     end
 
-    class HasAndBelongsToMany < ::ActiveRecord::Associations::Preloader::HasAndBelongsToMany
-      include Dase::PreloaderMethods
-    end
-
     # Not fully implemented yet
     class HasManyThrough < ::ActiveRecord::Associations::Preloader::HasManyThrough
       include Dase::PreloaderMethods
 
-      def prefixed_foreign_key
+      def foreign_key
         "#{reflection.active_record.table_name}.#{reflection.active_record_primary_key}"
       end
 
       def records_for(ids)
         reflection.active_record.joins(reflection.name).
-            where(prefixed_foreign_key => ids)
+            where(foreign_key => ids)
       end
     end
 
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    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)
+    def preloader_for(reflection, owners, rhs_klass)
+      return NullPreloader unless rhs_klass
+
+      if owners.first.association(reflection.name).loaded?
+        return AlreadyLoaded
+      end
+
       case reflection.macro
         when :has_many
-          if reflection.options[:through]
-            HasManyThrough
-            #raise NotImplementedError, "The support for HasManyThrough associations is not implemented yet"
-          else
-            HasMany
-          end
+          reflection.options[:through] ? HasManyThrough : HasMany
         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
+        else
+          raise NotImplementedError, "#{reflection.macro} not supported"
       end
     end
   end

data/lib/dase/preloader_methods.rb

@@ -1,29 +1,38 @@
 module Dase
   module PreloaderMethods
-
-    def initialize(klass, owners, reflection, preload_options)
-      preload_options = preload_options.reject { |k, _| k == :association }
-      @dase_counter_name = preload_options.delete(:as)
-      @dase_scope_to_merge = preload_options.delete(:only)
-      super(klass, owners, reflection, preload_options)
-    end
-
-    def prefixed_foreign_key
-      "#{scoped.quoted_table_name}.#{reflection.foreign_key}"
+    def foreign_key
+      reflection.klass.arel_table[reflection.foreign_key]
     end
 
-    def preload
+    def preload(preloader)
       pk = model.primary_key.to_sym
       ids = owners.map(&pk)
       scope = records_for(ids)
-      scope = scope.merge(@dase_scope_to_merge) if @dase_scope_to_merge
-      counters_hash = scope.count(group: prefixed_foreign_key)
+
+      # applying options like :where => ... or :conditions => ..., or -> {....}
+      scope = apply_association_options(preloader.options.clone, scope)
+
+      # the actual magic of attaching counters to the records comes here
+      counters_hash = scope.group(foreign_key).count(Arel.star)
       owners.each do |owner|
-        owner.define_singleton_method(@dase_counter_name) do
+        owner.define_singleton_method(preloader.options[:as]) do
           counters_hash[owner[pk]] || 0
         end
       end
     end
 
+    def apply_association_options(options, scope)
+      proc = options.delete(:proc)
+
+      # applying proc syntax: -> {...}
+      scope = scope.instance_eval(&proc) if proc
+
+      options.slice(*VALID_ASSOCIATION_OPTIONS).each do |key, value|
+        scope = scope.send(key, value)
+      end
+
+      scope
+    end
+
   end
 end

data/lib/dase/version.rb

@@ -1,3 +1,3 @@
 module Dase
-  VERSION = '3.2.9'
+  VERSION = '4.1.0'
 end

data/test/fixtures/author.rb

@@ -1,8 +1,6 @@
 class Author < ActiveRecord::Base
-  attr_accessible :name
-
   has_many :books
-  has_many :old_books, :class_name => "Book", :conditions => {:year => 1990}
+  has_many :old_books, -> { where year: 1990 }, class_name: 'Book'
 
   has_many :quotes, :through => :books
   has_many :scores, :through => :quotes

data/test/fixtures/book.rb

@@ -1,6 +1,4 @@
 class Book < ActiveRecord::Base
-  attr_accessible :title, :year
-
   belongs_to :author
   has_many :quotes
 

data/test/helper.rb

@@ -1,12 +1,11 @@
-# borrowed from https://github.com/ernie/meta_where/blob/master/test/helper.rb
-# with slight modifications
-require "rubygems"
-require "bundler"
+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')
@@ -19,12 +18,10 @@ ActiveRecord::Base.establish_connection(
 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::Migration.verbose = false
+load File.join(FIXTURES_PATH, 'schema.rb')
 
-ActiveRecord::Fixtures.create_fixtures(FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+ActiveRecord::FixtureSet.create_fixtures(FIXTURES_PATH, ActiveRecord::Base.connection.tables)
 
-class Test::Unit::TestCase
-end
+# require 'pry' rescue nil # use it when enabled in gemspec
+require 'minitest/autorun'

data/test/test_dase.rb

@@ -1,104 +1,108 @@
 require 'helper'
 
-class TestBase < Test::Unit::TestCase
-
+describe 'includes_count_of' do
   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 "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 }
-      # 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
-
-    should "count books for year 2012 using :only option" do
-      dase_counts = Author.includes_count_of(:books, :only => Book.year2012).order(:name).map { |a| a.books_count }
-      # the order is: Bobby, Joe, Teddy - due to order(:name)
-      true_counts = [0, 1, 0] # see books.yml
-      assert_equal true_counts, dase_counts, "results mismatch"
-    end
-
-    should "allow merge (nil) on a scope with includes_count_of" do
-      assert_equal 3, Author.includes_count_of(:books).merge(nil).all.size
-    end
-
-    # pending "apply: lambda {where...}"
-
-    should "count likes" do
-      dase_counts = Author.order(:name).includes_count_of(:scores).map { |a| a.scores_count }
-      # the order is: Bobby, Joe, Teddy - due to order(:name)
-      true_counts = [0, 2, 0] # see likes.yml
-      assert_equal true_counts, dase_counts, "results mismatch"
-    end
-
-    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
-
-    should 'support multiple arguments' do
-      joe = Author.includes_count_of(:books, :old_books).where(:name => 'Joe').first
-      assert_equal 3, joe.books_count, "Invalid books_count"
-      assert_equal 2, joe.old_books_count, "Invalid old_books_count"
-    end
-  end
-
-  context 'test' do
-    should 'work with find_each' do
-      # the order is: Bobby, Joe, Teddy - due to sort_by(:name)
-      records = []
-      Author.includes_count_of(:books).find_each(batch_size: 2) { |r| records << r }
-      dase_count = records.sort_by(&:name).map { |a| a.books_count }
-      assert_equal [1, 3, 0], dase_count, "dase countings failed" # see books.yml
-    end
+  before do
+    @bobby, @joe, @teddy = Author.order(:name).all
+  end
+
+  it '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
+
+  it 'should respond_to the counter method' do
+    assert_equal true, Author.includes_count_of(:books).first.respond_to?(:books_count), "doesn't respond'"
+  end
+
+  it 'should sneeze through scope definitions' do
+    assert_equal true, Author.with_count_of_books.first.respond_to?(:books_count), "doesn't respond'"
+  end
+
+  it '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
+
+  it '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
+
+  it '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
+
+  it '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
+
+  it 'should support :proc option (where year 1990)' do
+    traditional_counts = Author.order(:name).map { |a| a.books.where(:year => 1990).count }
+    dase_counts = Author.includes_count_of(:books, :proc => proc { where(: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
+
+  it 'should count books for year 2012 using :only option' do
+    dase_counts = Author.includes_count_of(:books, :only => Book.year2012).order(:name).map { |a| a.books_count }
+    # the order is: Bobby, Joe, Teddy - due to order(:name)
+    true_counts = [0, 1, 0] # see books.yml
+    assert_equal true_counts, dase_counts, "results mismatch"
+  end
+
+  it 'should allow merge (nil) on a scope with includes_count_of' do
+    assert_equal 3, Author.includes_count_of(:books).merge(nil).all.size
+  end
+
+  # pending "apply: lambda {where...}"
+
+  it 'should count likes' do
+    dase_counts = Author.order(:name).includes_count_of(:scores).map { |a| a.scores_count }
+    # the order is: Bobby, Joe, Teddy - due to order(:name)
+    true_counts = [0, 2, 0] # see likes.yml
+    assert_equal true_counts, dase_counts, "results mismatch"
+  end
+
+  it '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
+
+  it 'should support multiple arguments' do
+    joe = Author.includes_count_of(:books, :old_books).where(:name => 'Joe').first
+    assert_equal 3, joe.books_count, "Invalid books_count"
+    assert_equal 2, joe.old_books_count, "Invalid old_books_count"
+  end
+
+  it 'should work with find_each' do
+    # the order is: Bobby, Joe, Teddy - due to sort_by(:name)
+    records = []
+    Author.includes_count_of(:books).find_each(batch_size: 2) { |r| records << r }
+    dase_count = records.sort_by(&:name).map { |a| a.books_count }
+    assert_equal [1, 3, 0], dase_count, "dase countings failed" # see books.yml
   end
 end
+

metadata

@@ -1,99 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: dase
 version: !ruby/object:Gem::Version
-  version: 3.2.9
+  version: 4.1.0
 platform: ruby
 authors:
 - Vladimir Yartsev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-30 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '4.0'
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.3
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.3
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 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                      "