goldiloader 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3912274cc2f34e5dafb2a3b1d8ee8e3f6521885e
-  data.tar.gz: 72e93497e463d924c5c06c49df9d10cb7427170a
+  metadata.gz: 5e5d374d8cba8f3ed0e484f0030a896af17c6315
+  data.tar.gz: 0749a259d93c68ff35c45207edfc7d87648b70c5
 SHA512:
-  metadata.gz: 80396bbcaddfe170d4fd0db9a199839ef07c65d4fbfe8947de40dd31ab0500c86db372c11b105f3efaa980506402582af656da202088d7cd559c1f2d0dc10521
-  data.tar.gz: 060d399492cbbcd68cdb053fbc08c91781826404678e694287768d770c42736b39e5ad8e06cbad4600c0b2262fee4af4df469232fd973b6ccadb562c969d34ec
+  metadata.gz: 436cb0208f7cba5db8779af7ef9ad3d539ed988a2e48db1d8cbd3735885330afccba1844f8bbe8f540d5c37fc652cfe59c4edae7dc0c68cbc7282e153a209880
+  data.tar.gz: 41c5e5916200de2d44aa8228d18aa2ddc01a2e38dd29b4526212c51a3a27dae028602866e815baeb889a6277c4d1a9ac000c4f96b876b51592152060b27ae85a

data/.travis.yml

@@ -1,9 +1,9 @@
 language: ruby
 env:
   matrix:
-    - RAILS_VERSION="~> 3.2.18" JRUBY_OPTS="$JRUBY_OPTS --debug"
-    - RAILS_VERSION="~> 4.0.5" JRUBY_OPTS="$JRUBY_OPTS --debug"
-    - RAILS_VERSION="~> 4.1.1" JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - RAILS_VERSION="~> 3.2.19" JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - RAILS_VERSION="~> 4.0.10" JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - RAILS_VERSION="~> 4.1.6" JRUBY_OPTS="$JRUBY_OPTS --debug"
 rvm:
   - 1.9.3
   - 2.0.0

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+### 0.0.6 (unreleased)
+* Workaround [issue 16](https://github.com/salsify/goldiloader/issues/16) by not auto-eager loading 
+  has_and_belongs_to_many associations with a uniq in Rails 3.2 since Rails doesn't eager load them 
+  properly.
+* Fix [issue 17](https://github.com/salsify/goldiloader/issues/17) - models eager loaded via an explicit
+  call to eager_load now auto eager load nested models.
+
 ### 0.0.5
 
 * Fix ActiveRecord and ActiveSupport dependencies to work with versions greater than 4.1.0. Thanks for the pull

data/README.md

@@ -68,7 +68,7 @@ Or install it yourself as:
 
 ## Usage
 
-By default all associations will be automatically eager loaded when they are first accessed so hopefully most use cases should require no additional configuration. 
+By default all associations will be automatically eager loaded when they are first accessed so hopefully most use cases should require no additional configuration. Note you're still free to explicitly eager load associations via `eager_load`, `includes`, or `preload`.
 
 ### Association Options
 
@@ -124,9 +124,55 @@ class Blog < ActiveRecord::Base
 end
 ```
 
+## Limitations
+
+Goldiloader leverages the ActiveRecord eager loader so it shares some of the same limitations. 
+
+### has_one associations that rely on a SQL limit
+
+You should not try to auto eager load (or regular eager load) `has_one` associations that actually correspond to multiple records and rely on a SQL limit to only return one record. Consider the following example:
+
+```
+class Blog < ActiveRecord::Base
+  has_many :posts
+  has_one :most_recent_post, -> { order(published_at: desc) }, class_name: 'Post'
+end
+```
+
+With standard Rails lazy loading the `most_recent_post` association is loaded with a query like this:
+
+```
+SELECT * FROM posts WHERE blog_id = 1 ORDER BY published_at DESC LIMIT 1
+```
+
+With auto eager loading (or regular eager loading) the `most_recent_post` association is loaded with a query like this:
+
+```
+SELECT * FROM posts WHERE blog_id IN (1,2,3,4,5) ORDER BY published_at DESC
+```
+
+Notice the SQL limit can no longer be used which results in fetching all posts for each blog. This can cause severe performance problems if there are a large number of posts. 
+
+### Other Limitations
+
+Associations with any of the following options cannot be eager loaded:
+
+* `limit`
+* `offset`
+* `finder_sql`
+* `group` (due to a Rails bug)
+* `from` (due to a Rails bug)
+* `unscope` (due to a Rails bug)
+* `joins` (due to a Rails bug)
+* `uniq` (only Rails 3.2 - due to a Rails bug)
+
+Goldiloader detects associations with any of these options and disables automatic eager loading on them.
+
 ## Status
 
-This gem is tested with Rails 3.2, 4.0, and 4.1 using MRI 1.9.3, 2.0.0, 2.1.0 and JRuby in 1.9 mode. [Salsify](http://salsify.com) is not yet using this gem in production so proceed with caution. Let us know if you find any issues or have any other feedback. 
+This gem is tested with Rails 3.2, 4.0, and 4.1 using MRI 1.9.3, 2.0.0, 2.1.0 and JRuby in 1.9 mode. 
+
+Let us know if you find any issues or have any other feedback. 
 
 ## Change log
 

data/lib/goldiloader/active_record_patches.rb

@@ -32,9 +32,7 @@ ActiveRecord::Relation.class_eval do
     return exec_queries_without_auto_include if loaded?
 
     models = exec_queries_without_auto_include
-    # Add all loaded models to the same AutoIncludeContext
-    auto_include_context = Goldiloader::AutoIncludeContext.new
-    auto_include_context.register_models(models)
+    Goldiloader::AutoIncludeContext.register_models(models, eager_load_values)
     models
   end
 
@@ -68,7 +66,7 @@ ActiveRecord::Associations::Association.class_eval do
         !association_info.finder_sql? &&
         # Joins not properly eager loaded - See https://github.com/salsify/goldiloader/issues/11
         !association_info.joins? &&
-        # Unscope not properly eager loaded - https://github.com/salsify/goldiloader/issues/13
+        # Unscope not properly eager loaded - See https://github.com/salsify/goldiloader/issues/13
         !association_info.unscope?
   end
 
@@ -131,6 +129,16 @@ end
   end
 end
 
+# uniq in Rails 3 not properly eager loaded - See https://github.com/salsify/goldiloader/issues/16
+if ActiveRecord::VERSION::MAJOR < 4
+  ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
+    def eager_loadable?
+      association_info = Goldiloader::AssociationInfo.new(self)
+      super && !association_info.uniq?
+    end
+  end
+end
+
 # The CollectionProxy just forwards exists? to the underlying scope so we need to intercept this and
 # force it to use size which handles fully_load properly.
 ActiveRecord::Associations::CollectionProxy.class_eval do

data/lib/goldiloader/association_info.rb

@@ -43,6 +43,10 @@ module Goldiloader
         (@association.association_scope.joins_values.size - num_through_joins) > 0
       end
 
+      def uniq?
+        @association.association_scope.uniq_value
+      end
+
       private
 
       def num_through_joins
@@ -79,6 +83,10 @@ module Goldiloader
         # Rails 3 didn't support joins for associations
         false
       end
+
+      def uniq?
+        @association.options[:uniq]
+      end
     end
 
   end

data/lib/goldiloader/auto_include_context.rb

@@ -8,6 +8,26 @@ module Goldiloader
       @models = []
     end
 
+    def self.register_models(models, included_associations = nil)
+      auto_include_context = Goldiloader::AutoIncludeContext.new
+      auto_include_context.register_models(models)
+
+      Array.wrap(included_associations).each do |included_association|
+        associations = included_association.is_a?(Hash) ?
+            included_association.keys : Array.wrap(included_association)
+        nested_associations = included_association.is_a?(Hash) ?
+            included_association : Hash.new([])
+
+        associations.each do |association|
+          nested_models = models.flat_map do |model|
+            model.association(association).target
+          end
+
+          register_models(nested_models, nested_associations[association])
+        end
+      end
+    end
+
     def register_models(models)
       Array.wrap(models).each do |model|
         model.auto_include_context = self

data/lib/goldiloader/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Goldiloader
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/spec/db/schema.rb

@@ -111,6 +111,10 @@ class Post < ActiveRecord::Base
     has_many :unique_tags, through: :post_tags, source: :tag, uniq: true, class_name: 'Tag'
   end
 
+  if ActiveRecord::VERSION::MAJOR < 4
+    has_and_belongs_to_many :unique_tags_has_and_belongs, join_table: :post_tags, class_name: 'Tag', uniq: true
+  end
+
   after_destroy :after_post_destroy
 
   if Goldiloader::Compatibility.mass_assignment_security_enabled?

data/spec/goldiloader/auto_include_context_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Goldiloader::AutoIncludeContext do
+  describe ".register_models" do
+    context "when included_associations is an array of symbols" do
+      let!(:roots) do
+        [
+          create_mock_model(cars: cars.take(2), fruit: fruits.first),
+          create_mock_model(cars: cars.drop(2).take(2), fruit: fruits.last)
+        ]
+      end
+      let!(:cars) { create_mock_models(4) }
+      let!(:fruits) { create_mock_models(2) }
+
+      before do
+        Goldiloader::AutoIncludeContext.register_models(roots, [:cars, :fruit])
+      end
+
+      it "sets the AutoIncludeContext for roots" do
+        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
+        expect(roots.first.auto_include_context.models).to match_array(roots)
+      end
+
+      it "sets the AutoIncludeContext for singluar nested associations" do
+        expect(fruits.map(&:auto_include_context).uniq.size).to eq 1
+        expect(fruits.first.auto_include_context.models).to match_array(fruits)
+      end
+
+      it "sets the AutoIncludeContext for collection nested associations" do
+        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
+        expect(cars.first.auto_include_context.models).to match_array(cars)
+      end
+    end
+
+    context "when included_associations is a hash" do
+      let!(:roots) do
+        [
+          create_mock_model(car: cars.first),
+          create_mock_model(car: cars.last)
+        ]
+      end
+
+      let!(:cars) do
+        [
+          create_mock_model(wheels: wheels.take(4)),
+          create_mock_model(wheels: wheels.drop(4).take(4))
+        ]
+      end
+
+      let!(:wheels) { create_mock_models(8) }
+
+      before do
+        Goldiloader::AutoIncludeContext.register_models(roots, car: :wheels)
+      end
+
+      it "sets the AutoIncludeContext for roots" do
+        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
+        expect(roots.first.auto_include_context.models).to match_array(roots)
+      end
+
+      it "sets the AutoIncludeContext for child nested associations" do
+        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
+        expect(cars.first.auto_include_context.models).to match_array(cars)
+      end
+
+      it "sets the AutoIncludeContext for grandchild nested associations" do
+        expect(wheels.map(&:auto_include_context).uniq.size).to eq 1
+        expect(wheels.first.auto_include_context.models).to match_array(wheels)
+      end
+    end
+
+    context "when included_associations is an array that mixes hashes and symbols" do
+      let!(:roots) do
+        [
+          create_mock_model(car: cars.first, person: people.first),
+          create_mock_model(car: cars.last, person: people.last)
+        ]
+      end
+
+      let!(:people) { create_mock_models(2) }
+
+      let!(:cars) do
+        [
+          create_mock_model(wheels: wheels.take(4)),
+          create_mock_model(wheels: wheels.drop(4).take(4))
+        ]
+      end
+
+      let!(:wheels) { create_mock_models(8) }
+
+      before do
+        Goldiloader::AutoIncludeContext.register_models(roots, [:person, car: :wheels])
+      end
+
+      it "sets the AutoIncludeContext for roots" do
+        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
+        expect(roots.first.auto_include_context.models).to match_array(roots)
+      end
+
+      it "sets the AutoIncludeContext for child nested associations specified with a symbol" do
+        expect(people.map(&:auto_include_context).uniq.size).to eq 1
+        expect(people.first.auto_include_context.models).to match_array(people)
+      end
+
+      it "sets the AutoIncludeContext for child nested associations specified with a hash" do
+        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
+        expect(cars.first.auto_include_context.models).to match_array(cars)
+      end
+
+      it "sets the AutoIncludeContext for grandchild nested associations" do
+        expect(wheels.map(&:auto_include_context).uniq.size).to eq 1
+        expect(wheels.first.auto_include_context.models).to match_array(wheels)
+      end
+    end
+
+    def create_mock_models(num)
+      num.times.map { create_mock_model }
+    end
+
+    def create_mock_model(associations = {})
+      model = AutoIncludeContextMockModel.new
+      associations.each do |association, models|
+        allow(model).to receive(:association).with(association) do
+          OpenStruct.new(target: models)
+        end
+      end
+      model
+    end
+
+    AutoIncludeContextMockModel = Struct.new(:auto_include_context)
+  end
+end

data/spec/goldiloader/goldiloader_spec.rb

@@ -244,6 +244,46 @@ describe Goldiloader do
     expect { post.save! }.to_not raise_error
   end
 
+  context "with manual eager loading" do
+    let(:blogs) { Blog.order(:name).send(load_method, :posts).to_a }
+
+    before do
+      blogs.first.posts.to_a.first.author
+    end
+
+    shared_examples "it auto-eager loads associations of manually eager loaded associations" do
+      specify do
+        blogs.flat_map(&:posts).drop(1).each do |blog|
+          expect(blog.association(:author)).to be_loaded
+        end
+
+        expect(blogs.first.posts.first.author).to eq author1
+        expect(blogs.first.posts.second.author).to eq author2
+        expect(blogs.second.posts.first.author).to eq author3
+        expect(blogs.second.posts.second.author).to eq author1
+        expect(Post).to have_received(:find_by_sql).at_most(:once)
+      end
+    end
+
+    context "via includes" do
+      let(:load_method) { :includes }
+
+      it_behaves_like "it auto-eager loads associations of manually eager loaded associations"
+    end
+
+    context "via eager_load" do
+      let(:load_method) { :eager_load }
+
+      it_behaves_like "it auto-eager loads associations of manually eager loaded associations"
+    end
+
+    context "via preload" do
+      let(:load_method) { :preload }
+
+      it_behaves_like "it auto-eager loads associations of manually eager loaded associations"
+    end
+  end
+
   context "with associations that can't be eager loaded" do
     let(:blogs) { Blog.order(:name).to_a }
 
@@ -372,6 +412,34 @@ describe Goldiloader do
         end
       end
     end
+
+    if ActiveRecord::VERSION::MAJOR < 4
+      context "unique_tags_has_and_belongs associations with a uniq" do
+        let!(:post1) do
+          Post.create! { |post| post.tags << child_tag1 << child_tag1 << child_tag3 }
+        end
+
+        let!(:post2) do
+          Post.create! { |post| post.tags << child_tag1 << child_tag1 << child_tag2 }
+        end
+
+        let(:posts) { Post.where(id: [post1.id, post2.id]).order(:id).to_a }
+
+        before do
+          posts.first.unique_tags_has_and_belongs.to_a
+        end
+
+        it "applies the uniq correctly" do
+          expect(posts.first.unique_tags_has_and_belongs.to_a.size).to eq 2
+        end
+
+        it "doesn't auto eager the association" do
+          posts.drop(1).each do |author|
+            expect(author.association(:unique_tags_has_and_belongs)).to_not be_loaded
+          end
+        end
+      end
+    end
   end
 
   context "associations with a uniq" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goldiloader
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Joel Turkel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-29 00:00:00.000000000 Z
+date: 2014-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -160,6 +160,7 @@ files:
 - lib/goldiloader/version.rb
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/goldiloader/auto_include_context_spec.rb
 - spec/goldiloader/goldiloader_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/salsify/goldiloader
@@ -182,12 +183,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Automatic Rails association eager loading
 test_files:
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/goldiloader/auto_include_context_spec.rb
 - spec/goldiloader/goldiloader_spec.rb
 - spec/spec_helper.rb