goldiloader 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cd22c993cb7fd5659c5371a85deb6c89ada5deb
+  data.tar.gz: 9a3ecaff4ef43be8ee6f376613e896cb9875be59
+SHA512:
+  metadata.gz: 1b8c078b155765e688e60c6471df92bff1a915812f9dada3ed8def41b65fc6783528adc4cb5890ae41f661baa3aec63189f68212ed52c7d66eaea33de991a2d7
+  data.tar.gz: dabb87bd0a802bca323364851e78e210a43e1e4c9139a4b6faf9908912a57c86f43c33622cc1ae694132dba1bed6b4f9e67214d23d65ce0a0fcc5d08ea266dea

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.iml
+*.rbc
+.bundle
+.config
+.idea/
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+log/
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,11 @@
+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"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Joel Turkel
+
+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,137 @@
+# Goldiloader
+
+[![Gem Version](https://badge.fury.io/rb/goldiloader.png)][gem]
+[![Build Status](https://secure.travis-ci.org/salsify/goldiloader.png?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/salsify/goldiloader.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/salsify/goldiloader/badge.png)][coveralls]
+
+[gem]: https://rubygems.org/gems/goldiloader
+[travis]: http://travis-ci.org/salsify/goldiloader
+[codeclimate]: https://codeclimate.com/github/salsify/goldiloader
+[coveralls]: https://coveralls.io/r/salsify/goldiloader
+
+Wouldn't it be awesome if ActiveRecord didn't make you think about eager loading and it just did the "right" thing by default? With Goldiloader it can!
+
+Consider the following models:
+
+```
+class Blog < ActiveRecord::Base
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :blog
+end
+```
+
+Here are some sample queries without the Goldiloader:
+
+```
+> blogs = Blogs.limit(5).to_a
+# SELECT * FROM blogs LIMIT 5
+
+> blogs.each { |blog| blog.posts.to_a }
+# SELECT * FROM posts WHERE blog_id = 1
+# SELECT * FROM posts WHERE blog_id = 2
+# SELECT * FROM posts WHERE blog_id = 3
+# SELECT * FROM posts WHERE blog_id = 4
+# SELECT * FROM posts WHERE blog_id = 5
+```
+
+Here are the same queries with the Goldiloader:
+
+```
+> blogs = Blogs.limit(5).to_a
+# SELECT * FROM blogs LIMIT 5
+
+> blogs.each { |blog| blog.posts.to_a }
+# SELECT * FROM posts WHERE blog_id IN (1,2,3,4,5)
+```
+
+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).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'goldiloader'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install goldiloader
+
+## 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. 
+
+### Association Options
+
+Goldiloader supports a few options on ActiveRecord associations to customize its behavior.
+
+#### auto_include
+
+You can disable automatic eager loading on specific associations with the `auto_include` option:
+
+```
+class Blog < ActiveRecord::Base
+  has_many :posts, auto_include: false
+end
+```
+
+#### fully_load
+
+There are several association methods that ActiveRecord can either execute on in memory models or push down into SQL depending on whether or not the association is loaded. This includes the following methods:
+
+* `first`
+* `second`
+* `third`
+* `fourth`
+* `fifth`
+* `forty_two` (one of the hidden gems in Rails 4.1)
+* `last`
+* `size`
+* `ids_reader`
+* `empty?`
+* `exists?`
+
+This can cause problems for certain usage patterns if we're no longer specifying eager loads:
+
+```
+> blogs = Blogs.limit(5).to_a
+# SELECT * FROM blogs LIMIT 5
+
+> blogs.each do |blog| 
+    if blog.posts.exists? 
+      puts blog.posts
+    else
+      puts 'No posts'
+  end
+# SELECT 1 AS one FROM posts WHERE blog_id = 1 LIMIT 1
+# SELECT * FROM posts WHERE blog_id IN (1,2,3,4,5)
+```
+
+Notice the first call to `blog.posts.exists?` was executed via SQL because the `posts` association wasn't yet loaded. The `fully_load` option can be used to force ActiveRecord to fully load the association (and do any necessary automatic eager loading) when evaluating methods like `exists?`:
+
+```
+class Blog < ActiveRecord::Base
+  has_many :posts, fully_load: true
+end
+```
+
+## 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. 
+
+## 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,9 @@
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.verbose = false
+end
+
+task default: :spec

data/goldiloader.gemspec

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'goldiloader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'goldiloader'
+  spec.version       = Goldiloader::VERSION
+  spec.authors       = ['Joel Turkel']
+  spec.email         = ['jturkel@salsify.com']
+  spec.description   = %q{Automatically eager loads Rails associations as associations are traversed}
+  spec.summary       = %q{Automatic Rails association eager loading}
+  spec.homepage      = 'https://github.com/salsify/goldiloader'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = Dir.glob('spec/**/*')
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', ENV.fetch('RAILS_VERSION', ['>= 3.2', '<= 4.1'])
+  spec.add_dependency 'activesupport', ENV.fetch('RAILS_VERSION', ['>= 3.2', '<= 4.1'])
+
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'database_cleaner', '>= 1.2'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2'
+  spec.add_development_dependency 'simplecov', '~> 0.7.1'
+
+  if RUBY_PLATFORM == 'java'
+    spec.add_development_dependency 'jdbc-sqlite3'
+    spec.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
+  else
+    spec.add_development_dependency 'sqlite3'
+  end
+
+end
+

data/lib/goldiloader.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'active_support/all'
+require 'active_record'
+require 'goldiloader/auto_include_context'
+require 'goldiloader/association_options'
+require 'goldiloader/association_loader'
+require 'goldiloader/model_registry'
+require 'goldiloader/active_record_patches'

data/lib/goldiloader/active_record_patches.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+module Goldiloader
+  module AutoIncludableModel
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :auto_include_context
+    end
+
+    def initialize_copy(other)
+      super
+      @auto_include_context = nil
+    end
+
+    def auto_include_context
+      @auto_include_context ||= Goldiloader::AutoIncludeContext.create_empty.register_model(self)
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Goldiloader::AutoIncludableModel)
+
+ActiveRecord::Relation.class_eval do
+
+  def exec_queries_with_auto_include
+    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.create_empty
+    auto_include_context.register_models(models)
+    models
+  end
+
+  alias_method_chain :exec_queries, :auto_include
+end
+
+ActiveRecord::Associations::Association.class_eval do
+
+  class_attribute :default_auto_include, :default_fully_load
+  self.default_auto_include = true
+  self.default_fully_load = false
+
+  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 }
+  end
+
+  def fully_load?
+    !loaded? && options.fetch(:fully_load) { self.class.default_fully_load }
+  end
+
+  def auto_include_context
+    @auto_include_context ||= Goldiloader::AutoIncludeContext.new(owner.auto_include_context.model_registry,
+                                                                  owner.auto_include_context.association_path + [reflection.name])
+  end
+
+  private
+
+  def load_with_auto_include(load_method, *args)
+    if loaded?
+      target
+    elsif auto_include?
+      Goldiloader::AssociationLoader.load(auto_include_context.model_registry, owner,
+                                          auto_include_context.association_path)
+      target
+    else
+      send("#{load_method}_without_auto_include", *args)
+    end
+  end
+
+end
+
+ActiveRecord::Associations::SingularAssociation.class_eval do
+
+  private
+
+  def find_target_with_auto_include(*args)
+    load_with_auto_include(:find_target, *args)
+  end
+
+  alias_method_chain :find_target, :auto_include
+end
+
+ActiveRecord::Associations::CollectionAssociation.class_eval do
+  # Force these methods to load the entire association for fully_load associations
+  [:first, :second, :third, :fourth, :fifth, :last, :size, :ids_reader, :empty?].each do |method|
+    # Some of these methods were added in Rails 4
+    next unless method_defined?(method)
+
+    aliased_target, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+    define_method("#{aliased_target}_with_fully_load#{punctuation}") do |*args, &block|
+      load_target if fully_load?
+      send("#{aliased_target}_without_fully_load#{punctuation}", *args, &block)
+    end
+
+    alias_method_chain method, :fully_load
+  end
+
+  private
+
+  def load_target_with_auto_include(*args)
+    load_with_auto_include(:load_target, *args)
+  end
+
+  alias_method_chain :load_target, :auto_include
+
+end
+
+[ActiveRecord::Associations::HasManyThroughAssociation, ActiveRecord::Associations::HasOneThroughAssociation].each do |klass|
+  klass.class_eval do
+    def auto_include?
+      # Only auto include through associations if the target association is auto-loadable
+      through_association = owner.association(through_reflection.name)
+      through_association.auto_include? && super
+    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
+  def exists?
+    @association.fully_load? ? size > 0 : super
+  end
+end

data/lib/goldiloader/association_loader.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+module Goldiloader
+  module AssociationLoader
+    extend self
+
+    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)
+      end
+
+      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
+
+      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)
+    end
+
+    private
+
+    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? &&
+        model.association(association_name).auto_include?
+    end
+
+  end
+end

data/lib/goldiloader/association_options.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Goldiloader
+  module AssociationOptions
+    extend self
+
+    OPTIONS = [:auto_include, :fully_load]
+
+    def register
+      if ::ActiveRecord::VERSION::MAJOR >= 4
+        ActiveRecord::Associations::Builder::Association.valid_options.concat(OPTIONS)
+      else
+        # Each subclass of CollectionAssociation will have its own copy of valid_options so we need
+        # to register the valid option for each one.
+        collection_association_classes.each do |assoc_class|
+          assoc_class.valid_options.concat(OPTIONS)
+        end
+      end
+    end
+
+    private
+
+    def collection_association_classes
+      # Association.descendants doesn't work well with lazy classloading :(
+      [
+        ActiveRecord::Associations::Builder::Association,
+        ActiveRecord::Associations::Builder::BelongsTo,
+        ActiveRecord::Associations::Builder::HasAndBelongsToMany,
+        ActiveRecord::Associations::Builder::HasMany,
+        ActiveRecord::Associations::Builder::HasOne,
+        ActiveRecord::Associations::Builder::SingularAssociation
+      ]
+    end
+  end
+end
+
+Goldiloader::AssociationOptions.register

data/lib/goldiloader/auto_include_context.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Goldiloader
+  class AutoIncludeContext < Struct.new(:model_registry, :association_path)
+    def self.create_empty
+      Goldiloader::AutoIncludeContext.new(Goldiloader::ModelRegistry.new, [])
+    end
+
+    def register_models(models)
+      Array.wrap(models).each do |model|
+        model.auto_include_context = self
+        model_registry.register(model, association_path)
+      end
+      self
+    end
+
+    alias_method :register_model, :register_models
+  end
+end

data/lib/goldiloader/model_registry.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+module Goldiloader
+  class ModelRegistry
+    def initialize
+      @registry = {}
+    end
+
+    def register(record, association_path)
+      key = registry_key(record, association_path)
+      @registry[key] ||= []
+      @registry[key] << record
+    end
+
+    # Returns all models with the same base class loaded from the same association path
+    def peers(record, association_path)
+      @registry.fetch(registry_key(record, association_path), [])
+    end
+
+    private
+
+    def registry_key(record, association_path)
+      [record.class.base_class, association_path]
+    end
+  end
+end

data/lib/goldiloader/version.rb

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

data/spec/db/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"

data/spec/db/schema.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table(:blogs, force: true) do |t|
+    t.string :name
+  end
+
+  create_table(:posts, force: true) do |t|
+    t.string :title
+    t.integer :blog_id
+    t.integer :author_id
+  end
+
+  create_table(:users, force: true) do |t|
+    t.string :name
+  end
+
+  create_table(:addresses, force: true) do |t|
+    t.string :city
+    t.integer :user_id
+  end
+
+  create_table(:groups, force: true) do |t|
+    t.string :name
+  end
+
+  create_table(:tags, force: true) do |t|
+    t.string :name
+    t.integer :parent_id
+    t.string :owner_type
+    t.integer :owner_id
+  end
+
+  create_table(:post_tags, force: true) do |t|
+    t.integer :post_id
+    t.integer :tag_id
+  end
+end
+
+class Tag < ActiveRecord::Base
+  belongs_to :parent, class_name: 'Tag'
+  has_many :children, class_name: 'Tag', foreign_key: :parent_id
+
+  belongs_to :owner, polymorphic: true
+  has_many :post_tags
+  has_many :posts, through: :post_tags
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :name
+  end
+end
+
+class PostTag < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :tag
+end
+
+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'
+  has_many :authors, through: :posts
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :name
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :blog
+  belongs_to :blog_without_auto_include, auto_include: false, class_name: 'Blog', foreign_key: :blog_id
+  belongs_to :author, class_name: 'User'
+  has_many :post_tags
+  has_many :tags, through: :post_tags
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :title
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :posts, foreign_key: :author_id
+  has_many :tags, as: :owner
+  has_one :address
+  has_one :address_without_auto_include, auto_include: false, class_name: 'Address'
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :name
+  end
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :user
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :city
+  end
+end
+
+class Group < ActiveRecord::Base
+  has_many :tags, as: :owner
+
+  if Goldiloader::Compatibility.mass_assignment_security_enabled?
+    attr_accessible :name
+  end
+end

data/spec/goldiloader/goldiloader_spec.rb

@@ -0,0 +1,399 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe Goldiloader do
+  let!(:author1) do
+    User.create!(name: 'author1') { |u| u.address = Address.new(city: 'author1-city') }
+  end
+
+  let!(:author2) do
+    User.create!(name: 'author2') { |u| u.address = Address.new(city: 'author2-city') }
+  end
+
+  let!(:author3) do
+    User.create!(name: 'author3') { |u| u.address = Address.new(city: 'author3-city') }
+  end
+
+  let!(:group1) { Group.create!(name: 'group1') }
+
+  let!(:parent_tag1) { Tag.create!(name: 'parent1') { |t| t.owner = group1 } }
+  let!(:child_tag1) { parent_tag1.children.create!(name: 'parent1-child1') { |t| t.owner = author1 } }
+  let!(:child_tag2) { parent_tag1.children.create!(name: 'parent1-child2') { |t| t.owner = group1 } }
+  let!(:parent_tag2) { Tag.create!(name: 'parent2') { |t| t.owner = group1 } }
+  let!(:child_tag3) { parent_tag2.children.create!(name: 'parent2-child1') { |t| t.owner = author2 } }
+
+  let!(:blog1) do
+    blog1 = Blog.create!(name: 'blog1')
+
+    blog1.posts.create!(title: 'blog1-post1') do |post|
+      post.author = author1
+      post.tags << child_tag1 << child_tag2
+    end
+
+    blog1.posts.create!(title: 'blog1-post2') do |post|
+      post.author = author2
+      post.tags << child_tag1
+    end
+
+    blog1
+  end
+
+  let!(:blog2) do
+    blog2 = Blog.create!(name: 'blog2')
+
+    blog2.posts.create!(title: 'blog2-post1') do |post|
+      post.author = author3
+      post.tags << child_tag1
+    end
+
+    blog2.posts.create!(title: 'blog2-post2') do |post|
+      post.author = author1
+      post.tags << child_tag3
+    end
+
+    blog2
+  end
+
+  before do
+    [Address, Blog, Post, Tag, User, Group].each do |klass|
+      allow(klass).to receive(:find_by_sql).and_call_original
+    end
+
+    ActiveRecord::Base.logger.info('Test setup complete')
+  end
+
+  it "auto eager loads has_many associations" do
+    blogs = Blog.order(:name).to_a
+
+    # Sanity check that associations aren't loaded yet
+    blogs.each do |blog|
+      expect(blog.association(:posts)).to_not be_loaded
+    end
+
+    # Force the first blogs first post to load
+    blogs.first.posts.to_a
+
+    blogs.each do |blog|
+      expect(blog.association(:posts)).to be_loaded
+    end
+
+    expect(blogs.first.posts.map(&:title)).to match_array(['blog1-post1', 'blog1-post2'])
+    expect(blogs.second.posts.map(&:title)).to match_array(['blog2-post1', 'blog2-post2'])
+
+    expect(Post).to have_received(:find_by_sql).once
+  end
+
+  it "auto eager loads belongs_to associations" do
+    posts = Post.order(:title).to_a
+
+    # Sanity check that associations aren't loaded yet
+    posts.each do |blog|
+      expect(blog.association(:blog)).to_not be_loaded
+    end
+
+    # Force the first post's blog to load
+    posts.first.blog
+
+    posts.each do |blog|
+      expect(blog.association(:blog)).to be_loaded
+    end
+
+    expect(posts.map(&:blog).map(&:name)).to eq(['blog1', 'blog1', 'blog2', 'blog2'])
+    expect(Blog).to have_received(:find_by_sql).once
+  end
+
+  it "auto eager loads has_one associations" do
+    users = User.order(:name).to_a
+
+    # Sanity check that associations aren't loaded yet
+    users.each do |user|
+      expect(user.association(:address)).to_not be_loaded
+    end
+
+    # Force the first user's address to load
+    users.first.address
+
+    users.each do |blog|
+      expect(blog.association(:address)).to be_loaded
+    end
+
+    expect(users.map(&:address).map(&:city)).to match_array(['author1-city', 'author2-city', 'author3-city'])
+    expect(Address).to have_received(:find_by_sql).once
+  end
+
+  it "auto eager loads nested associations" do
+    blogs = Blog.order(:name).to_a
+    blogs.first.posts.to_a.first.author
+
+    blogs.flat_map(&:posts).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).once
+  end
+
+  it "auto eager loads has_many through associations" do
+    blogs = Blog.order(:name).to_a
+    blogs.first.authors.to_a
+
+    blogs.each do |blog|
+      expect(blog.association(:authors)).to be_loaded
+    end
+
+    expect(blogs.first.authors).to match_array([author1, author2])
+    expect(blogs.second.authors).to match_array([author3, author1])
+    expect(User).to have_received(:find_by_sql).once
+  end
+
+  it "auto eager loads associations when the model is loaded via find" do
+    blog = Blog.find(blog1.id)
+    blog.posts.to_a.first.author
+
+    blog.posts.each do |blog|
+      expect(blog.association(:author)).to be_loaded
+    end
+  end
+
+  it "auto eager loads polymorphic associations" do
+    tags = Tag.where('parent_id IS NOT NULL').order(:name).to_a
+    tags.first.owner
+
+    tags.each do |tag|
+      expect(tag.association(:owner)).to be_loaded
+    end
+
+    expect(tags.first.owner).to eq author1
+    expect(tags.second.owner).to eq group1
+    expect(tags.third.owner).to eq author2
+  end
+
+  it "auto eager loads associations of polymorphic associations" do
+    tags = Tag.where('parent_id IS NOT NULL').order(:name).to_a
+    users = tags.map(&:owner).select {|owner| owner.is_a?(User) }.sort_by(&:name)
+    users.first.posts.to_a
+
+    users.each do |user|
+      expect(user.association(:posts)).to be_loaded
+    end
+
+    expect(users.first.posts).to eq Post.where(author_id: author1.id)
+    expect(users.second.posts).to eq Post.where(author_id: author2.id)
+  end
+
+  it "only auto eager loads associations loaded through the same path" do
+    root_tags = Tag.where(parent_id: nil).order(:name).to_a
+    root_tags.first.children.to_a
+
+    # Make sure we loaded all child tags
+    root_tags.each do |tag|
+      expect(tag.association(:children)).to be_loaded
+    end
+
+    # Force a load of a root tag's owner
+    root_tags.first.owner
+
+    # All root tag owners should be loaded
+    root_tags.each do |tag|
+      expect(tag.association(:owner)).to be_loaded
+    end
+
+    # Child tag owners should not be loaded
+    child_tags = root_tags.flat_map(&:children)
+    child_tags.each do |tag|
+      expect(tag.association(:owner)).to_not 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 }
+    let(:other_blog) { blogs.last }
+
+    before do
+      blog.posts.create(title: 'blog1-new-post')
+    end
+
+    it "returns the correct models for the modified has_many association" do
+      expect(blog.posts).to match_array Post.where(blog_id: blog.id)
+    end
+
+    it "doesn't auto eager load peers when accessing the modified has_many association" do
+      blog.posts.to_a
+      expect(other_blog.association(:posts)).to_not be_loaded
+    end
+
+    it "returns the correct models for the modified has_many association when accessing a peer" do
+      other_blog.posts.to_a
+      expect(blog.posts).to match_array Post.where(blog_id: blog.id)
+    end
+  end
+
+  context "when a has_many through association has in-memory changes" do
+    let!(:posts) { Post.order(:title).to_a }
+    let(:post) { posts.first }
+    let(:other_post) { posts.last }
+
+    before do
+      tag = Tag.create(name: 'new-tag')
+      post.post_tags.create(tag: tag)
+    end
+
+    it "returns the correct models for the modified has_many through association" do
+      expect(post.tags).to match_array PostTag.where(post_id: post.id).includes(:tag).map(&:tag)
+    end
+
+    it "doesn't auto eager load peers when accessing the modified has_many through association" do
+      post.tags.to_a
+      expect(other_post.association(:tags)).to_not be_loaded
+    end
+
+    it "returns the correct models for the modified has_many through association when accessing a peer" do
+      other_post.tags.to_a
+      expect(post.tags).to match_array PostTag.where(post_id: post.id).includes(:tag).map(&:tag)
+    end
+  end
+
+  context "with fully_load false" do
+
+    it "doesn't auto eager loads a has_many association when size is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts.size
+
+      blogs.each do |blog|
+        expect(blog.association(:posts)).to_not be_loaded
+      end
+    end
+
+    it "doesn't auto eager loads a has_many association when exists? is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts.exists?
+
+      blogs.each do |blog|
+        expect(blog.association(:posts)).to_not be_loaded
+      end
+    end
+
+    it "doesn't auto eager loads a has_many association when last is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts.last
+
+      blogs.each do |blog|
+        expect(blog.association(:posts)).to_not be_loaded
+      end
+    end
+
+    it "doesn't auto eager loads a has_many association when ids is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.post_ids
+
+      blogs.each do |blog|
+        expect(blog.association(:posts)).to_not be_loaded
+      end
+    end
+  end
+
+  context "with fully_load true" do
+
+    it "auto eager loads a has_many association when size is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts_fully_load.size
+
+      blogs.each do |blog|
+        expect(blog.association(:posts_fully_load)).to be_loaded
+      end
+    end
+
+    it "auto eager loads a has_many association when exists? is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts_fully_load.exists?
+
+      blogs.each do |blog|
+        expect(blog.association(:posts_fully_load)).to 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
+
+      blogs.each do |blog|
+        expect(blog.association(:posts_fully_load)).to be_loaded
+      end
+    end
+
+    it "auto eager loads a has_many association when ids is called" do
+      blogs = Blog.order(:name).to_a
+      blogs.first.posts_fully_load_ids
+
+      blogs.each do |blog|
+        expect(blog.association(:posts_fully_load)).to be_loaded
+      end
+    end
+
+  end
+
+  context "with auto_include disabled" do
+
+    it "doesn't auto eager load has_many associations" do
+      blogs = Blog.order(:name).to_a
+
+      # Force the first blogs first post to load
+      posts = blogs.first.posts_without_auto_include.to_a
+      expect(posts).to match_array Post.where(blog_id: blogs.first.id)
+
+      blogs.drop(1).each do |blog|
+        expect(blog.association(:posts_without_auto_include)).to_not be_loaded
+      end
+    end
+
+    it "doesn't auto eager load has_one associations" do
+      users = User.order(:name).to_a
+
+      # Force the first user's address to load
+      user = users.first
+      address = user.address_without_auto_include
+      expect(address).to eq Address.where(user_id: user.id).first
+
+      users.drop(1).each do |blog|
+        expect(blog.association(:address_without_auto_include)).to_not be_loaded
+      end
+    end
+
+    it "doesn't auto eager load belongs_to associations" do
+      posts = Post.order(:title).to_a
+      # Force the first post's blog to load
+      post = posts.first
+      blog = post.blog_without_auto_include
+      expect(blog).to eq Blog.where(id: post.blog_id).first
+
+      posts.drop(1).each do |blog|
+        expect(blog.association(:blog_without_auto_include)).to_not be_loaded
+      end
+    end
+
+    it "still auto eager loads nested associations" do
+      posts = Post.order(:title).to_a
+      # Force the first post's blog to load
+      blog = posts.first.blog_without_auto_include
+
+      # Load another blogs posts
+      other_blog = posts.last.blog_without_auto_include
+      other_blog.posts.to_a
+
+      blog.posts.to_a.first.tags.to_a
+
+      blog.posts.each do |post|
+        expect(post.association(:tags)).to be_loaded
+      end
+
+      other_blog.posts.each do |post|
+        expect(post.association(:tags)).to_not be_loaded
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+ add_filter 'spec'
+end
+
+require 'logger'
+require 'database_cleaner'
+require 'goldiloader'
+require 'yaml'
+
+spec_dir = File.dirname(__FILE__)
+Dir["#{spec_dir}/support/**/*.rb"].sort.each { |f| require f }
+
+FileUtils.makedirs('log')
+
+ActiveRecord::Base.logger = Logger.new('log/test.log')
+ActiveRecord::Base.logger.level = Logger::DEBUG
+ActiveRecord::Migration.verbose = false
+
+db_adapter = ENV.fetch('ADAPTER', 'sqlite3')
+config = YAML.load(File.read('spec/db/database.yml'))
+ActiveRecord::Base.establish_connection(config[db_adapter])
+require 'db/schema'
+
+RSpec.configure do |config|
+  config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/compatibility.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+require 'active_support/version'
+require 'active_record/version'
+
+module Goldiloader
+  module Compatibility
+
+    def self.mass_assignment_security_enabled?
+      ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: goldiloader
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Joel Turkel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Automatically eager loads Rails associations as associations are traversed
+email:
+- jturkel@salsify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- goldiloader.gemspec
+- lib/goldiloader.rb
+- lib/goldiloader/active_record_patches.rb
+- lib/goldiloader/association_loader.rb
+- lib/goldiloader/association_options.rb
+- lib/goldiloader/auto_include_context.rb
+- lib/goldiloader/model_registry.rb
+- lib/goldiloader/version.rb
+- spec/db/database.yml
+- spec/db/schema.rb
+- spec/goldiloader/goldiloader_spec.rb
+- spec/spec_helper.rb
+- spec/support/compatibility.rb
+homepage: https://github.com/salsify/goldiloader
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Automatic Rails association eager loading
+test_files:
+- spec/db/database.yml
+- spec/db/schema.rb
+- spec/goldiloader/goldiloader_spec.rb
+- spec/spec_helper.rb
+- spec/support/compatibility.rb