goldiloader 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cd22c993cb7fd5659c5371a85deb6c89ada5deb
-  data.tar.gz: 9a3ecaff4ef43be8ee6f376613e896cb9875be59
+  metadata.gz: 856cc3b8807810dbf9e6b357bbc460d4c0bec3ac
+  data.tar.gz: b8cd9a6f87ffa7a9427dd089ad7fcab7580361da
 SHA512:
-  metadata.gz: 1b8c078b155765e688e60c6471df92bff1a915812f9dada3ed8def41b65fc6783528adc4cb5890ae41f661baa3aec63189f68212ed52c7d66eaea33de991a2d7
-  data.tar.gz: dabb87bd0a802bca323364851e78e210a43e1e4c9139a4b6faf9908912a57c86f43c33622cc1ae694132dba1bed6b4f9e67214d23d65ce0a0fcc5d08ea266dea
+  metadata.gz: 020f3bb39360cf4253f738592bb06fc222d83c71d6a6b343ca7e4df36741bf937f6e5bd62d7faee8c83638a6b020e2f950176184b757ac0b11a0a88687057c17
+  data.tar.gz: 4d3f56fd3c361608314c2c057cf0cbb9620513db6ecbc0595ac9e8f95a72a115c04339f678877c83142ed278d52f03a503a66ff651958deb39bfe038d1fe44cf

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+### 0.0.4
+ 
+* Fix [issue 3](https://github.com/salsify/goldiloader/issues/3) - `exists?` method should take an argument 
+  — thanks for reporting [Bert Goethals](https://github.com/Bertg)
+* Fix [issue 4](https://github.com/salsify/goldiloader/issues/4) - Associations couldn't be loaded in after 
+  destroy callbacks — thanks for reporting [Bert Goethals](https://github.com/Bertg)
+* Fix [issue 6](https://github.com/salsify/goldiloader/issues/6) - Models in read only associations weren't
+  being marked as read only
+* Fix [issue 7](https://github.com/salsify/goldiloader/issues/7) - Don't attempt to eager load associations that
+  aren't eager loadable e.g. if they have a limit
+* Fix [issue 8](https://github.com/salsify/goldiloader/issues/8) - Handle eager loading associations whose 
+  accessor methods have been overridden.
+

data/README.md

@@ -50,7 +50,7 @@ Here are the same queries with the Goldiloader:
 
 Whoa! It automatically loaded all of the posts for our five blogs in a single database query without specifying any eager loads! Goldiloader assumes that you'll access all models loaded from a query in a uniform way. The first time you traverse an association on any of the models it will eager load the association for all the models. It even works with arbitrary nesting of associations.
 
-Read more about the motivation for the Goliloader in this [blog post](http://www.salsify.com/blog/automatic-eager-loading-rails/1869).
+Read more about the motivation for the Goldiloader in this [blog post](http://www.salsify.com/blog/automatic-eager-loading-rails/).
 
 ## Installation
 
@@ -128,6 +128,10 @@ end
 
 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. 
 
+## Change log
+
+See the [change log](https://github.com/salsify/goldiloader/blob/master/CHANGELOG.md).
+
 ## Contributing
 
 1. Fork it

data/lib/goldiloader.rb

@@ -3,6 +3,7 @@
 require 'active_support/all'
 require 'active_record'
 require 'goldiloader/auto_include_context'
+require 'goldiloader/association_info'
 require 'goldiloader/association_options'
 require 'goldiloader/association_loader'
 require 'goldiloader/model_registry'

data/lib/goldiloader/active_record_patches.rb

@@ -45,7 +45,7 @@ ActiveRecord::Associations::Association.class_eval do
   def auto_include?
     # We only auto include associations that don't have in-memory changes since the
     # Rails association Preloader clobbers any in-memory changes
-    !loaded? && target.blank? && options.fetch(:auto_include) { self.class.default_auto_include }
+    !loaded? && target.blank? && options.fetch(:auto_include) { self.class.default_auto_include } && eager_loadable?
   end
 
   def fully_load?
@@ -57,10 +57,18 @@ ActiveRecord::Associations::Association.class_eval do
                                                                   owner.auto_include_context.association_path + [reflection.name])
   end
 
+  def eager_loadable?
+    association_info = Goldiloader::AssociationInfo.new(self)
+    !association_info.limit? &&
+        !association_info.offset? &&
+        !association_info.group? &&
+        !association_info.from?
+  end
+
   private
 
   def load_with_auto_include(load_method, *args)
-    if loaded?
+    if loaded? && !stale_target?
       target
     elsif auto_include?
       Goldiloader::AssociationLoader.load(auto_include_context.model_registry, owner,
@@ -122,7 +130,10 @@ 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
-  def exists?
-    @association.fully_load? ? size > 0 : super
+  def exists?(*args)
+    # We don't fully_load the association when arguments are passed to exists? since Rails always
+    # pushes this query into the database without any caching (and it likely not a common
+    # scenario worth optimizing).
+    args.empty? && @association.fully_load? ? size > 0 : super
   end
 end

data/lib/goldiloader/association_info.rb

@@ -0,0 +1,51 @@
+module Goldiloader
+  class AssociationInfo
+
+    def initialize(association)
+      @association = association
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+      def read_only?
+        @association.association_scope.readonly_value.present?
+      end
+
+      def offset?
+        @association.association_scope.offset_value.present?
+      end
+
+      def limit?
+        @association.association_scope.limit_value.present?
+      end
+
+      def from?
+        @association.association_scope.from_value.present?
+      end
+
+      def group?
+        @association.association_scope.group_values.present?
+      end
+    else
+      def read_only?
+        @association.options[:readonly].present?
+      end
+
+      def offset?
+        @association.options[:offset].present?
+      end
+
+      def limit?
+        @association.options[:limit].present?
+      end
+
+      def from?
+        @association.options[:finder_sql].present?
+      end
+
+      def group?
+        @association.options[:group].present?
+      end
+    end
+
+  end
+end

data/lib/goldiloader/association_loader.rb

@@ -6,30 +6,62 @@ module Goldiloader
 
     def load(model_registry, model, association_path)
       *model_path, association_name = *association_path
-      models = model_registry.peers(model, model_path).select do |model|
-        load?(model, association_name)
+      models = model_registry.peers(model, model_path).select do |peer|
+        load?(peer, association_name)
       end
 
+      eager_load(models, association_name)
+
+      associated_models = associated_models(models, association_name)
+      # Workaround Rails #15853 by setting models read only
+      mark_read_only(associated_models) if read_only?(models, association_name)
+      auto_include_context = Goldiloader::AutoIncludeContext.new(model_registry, association_path)
+      auto_include_context.register_models(associated_models)
+    end
+
+    private
+
+    def eager_load(models, association_name)
       if Gem::Version.new(::ActiveRecord::VERSION::STRING) >= Gem::Version.new('4.1')
         ::ActiveRecord::Associations::Preloader.new.preload(models, [association_name])
       else
         ::ActiveRecord::Associations::Preloader.new(models, [association_name]).run
       end
+    end
 
-      associated_models = models.map { |model| model.send(association_name) }.flatten.compact.uniq
-      auto_include_context = Goldiloader::AutoIncludeContext.new(model_registry, association_path)
-      auto_include_context.register_models(associated_models)
+    def mark_read_only(models)
+      models.each(&:readonly!)
     end
 
-    private
+    def read_only?(models, association_name)
+      model = first_model_with_association(models, association_name)
+      if model.nil?
+        false
+      else
+        association_info = AssociationInfo.new(model.association(association_name))
+        association_info.read_only?
+      end
+    end
+
+    def first_model_with_association(models, association_name)
+      models.find { |model| has_association?(model, association_name) }
+    end
+
+    def associated_models(models, association_name)
+      # We can't just do model.send(association_name) because the association method may have been
+      # overridden
+      models.map { |model| model.association(association_name).target }.flatten.compact.uniq
+    end
 
     def load?(model, association_name)
       # Need to make sure the model actually has the association which won't always
       # be the case in STI hierarchies e.g. only a subclass might have the association
-      !model.destroyed? &&
-        model.class.reflect_on_association(association_name).present? &&
+      has_association?(model, association_name) &&
         model.association(association_name).auto_include?
     end
 
+    def has_association?(model, association_name)
+      model.class.reflect_on_association(association_name).present?
+    end
   end
 end

data/lib/goldiloader/version.rb

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

data/spec/db/schema.rb

@@ -60,11 +60,32 @@ class Blog < ActiveRecord::Base
   has_many :posts
   has_many :posts_without_auto_include, auto_include: false, class_name: 'Post'
   has_many :posts_fully_load, fully_load: true, class_name: 'Post'
+
+  if ActiveRecord::VERSION::MAJOR >= 4
+    has_many :read_only_posts, -> { readonly }, class_name: 'Post'
+    has_many :limited_posts, -> { limit(2) }, class_name: 'Post'
+    has_many :grouped_posts, -> { group(:blog_id) }, class_name: 'Post'
+    has_many :offset_posts, -> { offset(2) }, class_name: 'Post'
+    has_many :from_posts, -> { from('(select distinct blog_id from posts) as posts') }, class_name: 'Post'
+  else
+    has_many :read_only_posts, readonly: true, class_name: 'Post'
+    has_many :limited_posts, limit: 2, class_name: 'Post'
+    has_many :grouped_posts, group: :blog_id, class_name: 'Post'
+    has_many :offset_posts, offset: 2, class_name: 'Post'
+    has_many :from_posts, finder_sql: Proc.new { "select distinct blog_id from posts where blog_id = #{self.id}" },
+             class_name: 'Post'
+  end
+
+  has_many :posts_overridden, class_name: 'Post'
   has_many :authors, through: :posts
 
   if Goldiloader::Compatibility.mass_assignment_security_enabled?
     attr_accessible :name
   end
+
+  def posts_overridden
+    'boom'
+  end
 end
 
 class Post < ActiveRecord::Base
@@ -74,9 +95,21 @@ class Post < ActiveRecord::Base
   has_many :post_tags
   has_many :tags, through: :post_tags
 
+  if ActiveRecord::VERSION::MAJOR >= 4
+    has_many :unique_tags, -> { distinct }, through: :post_tags, source: :tag, class_name: 'Tag'
+  else
+    has_many :unique_tags, through: :post_tags, source: :tag, uniq: true, class_name: 'Tag'
+  end
+
+  after_destroy :after_post_destroy
+
   if Goldiloader::Compatibility.mass_assignment_security_enabled?
     attr_accessible :title
   end
+
+  def after_post_destroy
+    # Hook for tests
+  end
 end
 
 class User < ActiveRecord::Base

data/spec/goldiloader/goldiloader_spec.rb

@@ -209,6 +209,142 @@ describe Goldiloader do
     end
   end
 
+  it "auto eager loads associations that have been overridden" do
+    blogs = Blog.order(:name).to_a
+
+    blogs.first.association(:posts_overridden).load_target
+
+    blogs.each do |blog|
+      expect(blog.association(:posts_overridden)).to be_loaded
+    end
+  end
+
+  it "marks auto eager loaded models as read only when the association is read only" do
+    blog = Blog.first!
+    post = blog.read_only_posts.to_a.first
+    expect { post.save! }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it "doesn't mark auto eager loaded models as read only when the association is not read only" do
+    blog = Blog.first!
+    post = blog.posts.to_a.first
+    expect { post.save! }.to_not raise_error
+  end
+
+  context "with associations that can't be eager loaded" do
+    let(:blogs) { Blog.order(:name).to_a }
+
+    before do
+      blog1.posts.create!(title: 'blog1-post3')
+      blog2.posts.create!(title: 'blog2-post3')
+    end
+
+    shared_examples "it doesn't auto eager the association" do |association_name|
+      specify do
+        blogs.drop(1).each do |blog|
+          expect(blog.association(association_name)).to_not be_loaded
+        end
+      end
+    end
+
+    context "associations with a limit" do
+      before do
+        blogs.first.limited_posts.to_a
+      end
+
+      it "applies the limit correctly" do
+        expect(blogs.first.limited_posts.to_a.size).to eq 2
+      end
+
+      it_behaves_like "it doesn't auto eager the association", :limited_posts
+    end
+
+    context "associations with a group" do
+      before do
+        blogs.first.grouped_posts.to_a
+      end
+
+      it "applies the group correctly" do
+        expect(blogs.first.grouped_posts.to_a.size).to eq 1
+      end
+
+      it_behaves_like "it doesn't auto eager the association", :grouped_posts
+    end
+
+    context "associations with an offset" do
+      before do
+        blogs.first.offset_posts.to_a
+      end
+
+      it "applies the offset correctly" do
+        expect(blogs.first.offset_posts.to_a.size).to eq 1
+      end
+
+      it_behaves_like "it doesn't auto eager the association", :offset_posts
+    end
+
+    context "associations with an overridden from" do
+      before do
+        blogs.first.from_posts.to_a
+      end
+
+      it "applies the from correctly" do
+        expect(blogs.first.from_posts.to_a.size).to eq 1
+      end
+
+      it_behaves_like "it doesn't auto eager the association", :from_posts
+    end
+  end
+
+  context "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.to_a
+    end
+
+    it "applies the uniq correctly" do
+      expect(posts.first.unique_tags.to_a).to match_array([child_tag1, child_tag3])
+    end
+
+    it "auto eager the association" do
+      posts.each do |blog|
+        expect(blog.association(:unique_tags)).to be_loaded
+      end
+    end
+  end
+
+  context "when a model is destroyed" do
+    let!(:posts) { Post.where(blog_id: blog1.id).to_a }
+    let(:destroyed_post) { posts.first }
+    let(:other_post) { posts.last }
+
+    before do
+      blog_after_destroy = nil
+      destroyed_post.define_singleton_method(:after_post_destroy) do
+        blog_after_destroy = self.blog
+      end
+      destroyed_post.destroy
+      @blog_after_destroy = blog_after_destroy
+    end
+
+    it "can load associations in after_destroy callbacks" do
+      expect(@blog_after_destroy).to eq blog1
+    end
+
+    it "auto eager loads the associaton on other models" do
+      expect(other_post.association(:blog)).to be_loaded
+    end
+  end
+
   context "when a has_many association has in-memory changes" do
     let!(:blogs) { Blog.order(:name).to_a }
     let(:blog) { blogs.first }
@@ -317,6 +453,15 @@ describe Goldiloader do
       end
     end
 
+    it "doesn't auto eager load a has_many association when exists? is called with arguments" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts_fully_load.exists?(false)
+
+      blogs.each do |blog|
+        expect(blog.association(:posts_fully_load)).to_not be_loaded
+      end
+    end
+
     it "auto eager loads a has_many association when last is called" do
       blogs = Blog.order(:name).to_a
       blogs.first.posts_fully_load.last

data/spec/spec_helper.rb

@@ -49,3 +49,5 @@ RSpec.configure do |config|
     DatabaseCleaner.clean
   end
 end
+
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goldiloader
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Joel Turkel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -144,6 +144,7 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -151,6 +152,7 @@ files:
 - goldiloader.gemspec
 - lib/goldiloader.rb
 - lib/goldiloader/active_record_patches.rb
+- lib/goldiloader/association_info.rb
 - lib/goldiloader/association_loader.rb
 - lib/goldiloader/association_options.rb
 - lib/goldiloader/auto_include_context.rb