goldiloader 0.0.9 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5439cf46ad38cb53ae77b4b82480215d59ef665b
-  data.tar.gz: ef928602e0934eb6a372fb0476e9f807af0c4713
+  metadata.gz: c7414c0de13b4e9b5c87d8106cedfdb2028a3640
+  data.tar.gz: 2a0650488a2ebdc94d665fa12b3dc7d88282c791
 SHA512:
-  metadata.gz: 6f621c060cec10acadf3beca30afbc80442b22734873acb32c3430451f0b83a0d137760ad908ac56f6e74abde5bfad02ba9d994b4e5aa9b4c2425e29f8a905ce
-  data.tar.gz: 43e6573c8978dd21fced0f8848421a2ec2eaeeffdebda8b88625557477044a6a03deed854fcdedfdeaef8b3c978c5565aa597f37e0367485cb3de29c7e6639fe
+  metadata.gz: 46d11df02dbae98f7915b06df38937ba93937671433403ff1f161def9568b92cb1a310eb55eed6c9edb073e5851660bb890d7c324cafca12c99585d269ebd0e9
+  data.tar.gz: '09179806ac8786f88f059d0c3cba83c4a85acd7f9fe1794dca06ac6672da948b854264263c709911425689493c2932d7f242504a2b0d0d5f9818d0487b58da17'

data/lib/goldiloader/active_record_patches.rb

@@ -1,11 +1,15 @@
 # encoding: UTF-8
 
 module Goldiloader
-  module AutoIncludableModel
+  module BasePatch
     extend ActiveSupport::Concern
 
     included do
       attr_writer :auto_include_context
+
+      class << self
+        delegate :auto_include, to: :all
+      end
     end
 
     def initialize_copy(other)
@@ -22,131 +26,159 @@ module Goldiloader
       super
     end
   end
-end
-
-ActiveRecord::Base.send(:include, Goldiloader::AutoIncludableModel)
+  ::ActiveRecord::Base.include(::Goldiloader::BasePatch)
 
-ActiveRecord::Relation.class_eval do
+  module RelationPatch
+    def exec_queries
+      return super if loaded? || !auto_include_value
 
-  def exec_queries_with_auto_include
-    return exec_queries_without_auto_include if loaded?
-
-    models = exec_queries_without_auto_include
-    Goldiloader::AutoIncludeContext.register_models(models, eager_load_values)
-    models
-  end
+      models = super
+      Goldiloader::AutoIncludeContext.register_models(models, eager_load_values)
+      models
+    end
 
-  alias_method_chain :exec_queries, :auto_include
-end
+    def auto_include(auto_include = true)
+      spawn.auto_include!(auto_include)
+    end
 
-ActiveRecord::Associations::Association.class_eval do
+    def auto_include!(auto_include = true)
+      self.auto_include_value = auto_include
+      self
+    end
 
-  class_attribute :default_auto_include, :default_fully_load
-  self.default_auto_include = true
-  self.default_fully_load = false
+    def auto_include_value
+      # Note: Don't use get_value because that doesn't work properly with defaulting boolean values
+      @values.fetch(:auto_include, true)
+    end
 
-  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 } && eager_loadable?
+    def auto_include_value=(value)
+      if Goldiloader::Compatibility.rails_4?
+        raise ::ActiveRecord::Relation::ImmutableRelation if @loaded
+        check_cached_relation
+        @values[:auto_include] = value
+      elsif Goldiloader::Compatibility.rails_5_0?
+        assert_mutability!
+        @values[:auto_include] = value
+      else
+        set_value(:auto_include, value)
+      end
+    end
   end
+  ::ActiveRecord::Relation.prepend(::Goldiloader::RelationPatch)
+
+  module MergerPatch
+    private
 
-  def fully_load?
-    !loaded? && options.fetch(:fully_load) { self.class.default_fully_load }
+    def merge_single_values
+      relation.auto_include_value = other.auto_include_value
+      super
+    end
   end
+  ActiveRecord::Relation::Merger.prepend(::Goldiloader::MergerPatch)
 
-  private
+  module AssociationPatch
+    extend ActiveSupport::Concern
 
-  def eager_loadable?
-    association_info = Goldiloader::AssociationInfo.new(self)
-    !association_info.limit? &&
-        !association_info.offset? &&
-        !association_info.group? &&
-        !association_info.from? &&
-        !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 - See https://github.com/salsify/goldiloader/issues/13
-        !association_info.unscope? &&
-        !association_info.instance_dependent?
-  end
+    included do
+      class_attribute :default_fully_load
+      self.default_fully_load = false
+    end
 
-  def load_with_auto_include(load_method, *args)
-    if loaded? && !stale_target?
-      target
-    elsif auto_include?
-      Goldiloader::AssociationLoader.load(owner, reflection.name)
-      target
-    else
-      send("#{load_method}_without_auto_include", *args)
+    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? && eager_loadable?
     end
-  end
 
-end
+    def fully_load?
+      !loaded? && options.fetch(:fully_load) { self.class.default_fully_load }
+    end
 
-ActiveRecord::Associations::SingularAssociation.class_eval do
+    private
 
-  private
+    def eager_loadable?
+      association_info = Goldiloader::AssociationInfo.new(self)
+      !association_info.limit? &&
+        !association_info.offset? &&
+        (!association_info.has_one? || !association_info.order?) &&
+        (!association_info.group? || ::Goldiloader::Compatibility.group_eager_loadable?) &&
+        (!association_info.from? || ::Goldiloader::Compatibility.from_eager_loadable?) &&
+        !association_info.instance_dependent? &&
+        association_info.auto_include? &&
+        (!owner.destroyed? || ::Goldiloader::Compatibility.destroyed_model_associations_eager_loadable?)
+    end
 
-  def find_target_with_auto_include(*args)
-    load_with_auto_include(:find_target, *args)
+    def load_with_auto_include
+      if loaded? && !stale_target?
+        target
+      elsif auto_include?
+        Goldiloader::AssociationLoader.load(owner, reflection.name)
+        target
+      else
+        yield
+      end
+    end
   end
+  ::ActiveRecord::Associations::Association.include(::Goldiloader::AssociationPatch)
 
-  alias_method_chain :find_target, :auto_include
-end
+  module SingularAssociationPatch
+    private
 
-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)
+    def find_target(*args)
+      load_with_auto_include { super }
     end
-
-    alias_method_chain method, :fully_load
   end
+  ::ActiveRecord::Associations::SingularAssociation.prepend(::Goldiloader::SingularAssociationPatch)
 
-  private
+  module CollectionAssociationPatch
+    # Force these methods to load the entire association for fully_load associations
+    association_methods = [:size, :ids_reader, :empty?]
+    if Goldiloader::Compatibility::ACTIVE_RECORD_VERSION < ::Gem::Version.new('5.1')
+      association_methods.concat([:first, :second, :third, :fourth, :fifth, :last])
+    end
 
-  def load_target_with_auto_include(*args)
-    load_with_auto_include(:load_target, *args)
-  end
+    association_methods.each do |method|
+      define_method(method) do |*args, &block|
+        load_target if fully_load?
+        super(*args, &block)
+      end
+    end
 
-  alias_method_chain :load_target, :auto_include
+    def load_target(*args)
+      load_with_auto_include { super }
+    end
 
-end
+    if Goldiloader::Compatibility::ACTIVE_RECORD_VERSION >= ::Gem::Version.new('5.1')
+      def find_from_target?
+        fully_load? || super
+      end
+    end
+  end
+  ::ActiveRecord::Associations::CollectionAssociation.prepend(::Goldiloader::CollectionAssociationPatch)
 
-[ActiveRecord::Associations::HasManyThroughAssociation, ActiveRecord::Associations::HasOneThroughAssociation].each do |klass|
-  klass.class_eval do
+  module ThroughAssociationPatch
     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
-
-# 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?
+  ::ActiveRecord::Associations::HasManyThroughAssociation.prepend(::Goldiloader::ThroughAssociationPatch)
+  ::ActiveRecord::Associations::HasOneThroughAssociation.prepend(::Goldiloader::ThroughAssociationPatch)
+
+  module CollectionProxyPatch
+    # 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.
+    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).
+      if args.empty? && @association.fully_load?
+        size > 0
+      else
+        scope.exists?(*args)
+      end
     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?(*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
+  ::ActiveRecord::Associations::CollectionProxy.prepend(::Goldiloader::CollectionProxyPatch)
 end

data/lib/goldiloader/association_info.rb

@@ -7,109 +7,42 @@ module Goldiloader
       @association = association
     end
 
-    def finder_sql?
-      Goldiloader::Compatibility.association_finder_sql_enabled? &&
-        association_options[:finder_sql].present?
-    end
+    delegate :association_scope, :reflection, to: :@association
 
-    if ActiveRecord::VERSION::MAJOR >= 4
-      delegate :association_scope, :reflection, to: :@association
+    def has_one?
+      reflection.has_one?
+    end
 
-      def read_only?
-        association_scope && association_scope.readonly_value.present?
-      end
+    def offset?
+      association_scope && association_scope.offset_value.present?
+    end
 
-      def offset?
-        association_scope && association_scope.offset_value.present?
-      end
+    def limit?
+      association_scope && association_scope.limit_value.present?
+    end
 
-      def limit?
-        association_scope && association_scope.limit_value.present?
-      end
+    def auto_include?
+      association_scope.nil? || association_scope.auto_include_value
+    end
 
-      def from?
+    def from?
+      if ActiveRecord::VERSION::MAJOR >= 5
+        association_scope && association_scope.from_clause.present?
+      else
         association_scope && association_scope.from_value.present?
       end
+    end
 
-      def group?
-        association_scope && association_scope.group_values.present?
-      end
-
-      def joins?
-        # Yuck - Through associations will always have a join for *each* 'through' table
-        association_scope && (association_scope.joins_values.size - num_through_joins) > 0
-      end
-
-      def uniq?
-        association_scope && association_scope.uniq_value
-      end
-
-      def instance_dependent?
-        reflection.scope.present? && reflection.scope.arity > 0
-      end
-
-      def unscope?
-        Goldiloader::Compatibility.unscope_query_method_enabled? &&
-            association_scope &&
-            association_scope.unscope_values.present?
-      end
-
-      private
-
-      def num_through_joins
-        association = @association
-        count = 0
-        while association.is_a?(ActiveRecord::Associations::ThroughAssociation)
-          count += 1
-          association = association.owner.association(association.through_reflection.name)
-        end
-        count
-      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?
-        false
-      end
-
-      def group?
-        association_options[:group].present?
-      end
-
-      def joins?
-        # Rails 3 didn't support joins for associations
-        false
-      end
-
-      def uniq?
-        association_options[:uniq]
-      end
-
-      def instance_dependent?
-        # Rails 3 didn't support this
-        false
-      end
-
-      def unscope?
-        # Rails 3 didn't support this
-        false
-      end
+    def group?
+      association_scope && association_scope.group_values.present?
     end
 
-    private
+    def order?
+      association_scope && association_scope.order_values.present?
+    end
 
-    def association_options
-      @association.options
+    def instance_dependent?
+      reflection.scope.present? && reflection.scope.arity > 0
     end
   end
 end

data/lib/goldiloader/association_loader.rb

@@ -10,36 +10,12 @@ module Goldiloader
       end
 
       eager_load(models, association_name)
-
-      # Workaround Rails #15853 by setting models read only
-      if read_only?(models, association_name)
-        associated_models = associated_models(models, association_name)
-        mark_read_only(associated_models)
-      end
     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
-
-    def mark_read_only(models)
-      models.each(&:readonly!)
-    end
-
-    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
+      ::ActiveRecord::Associations::Preloader.new.preload(models, [association_name])
     end
 
     def first_model_with_association(models, association_name)

data/lib/goldiloader/association_options.rb

@@ -4,33 +4,28 @@ module Goldiloader
   module AssociationOptions
     extend self
 
-    OPTIONS = [:auto_include, :fully_load]
+    OPTIONS = [:fully_load].freeze
+
+    # This is only used in Rails 5+
+    module AssociationBuilderExtension
+      def self.build(model, reflection)
+        # We have no callbacks to register
+      end
+
+      def self.valid_options
+        OPTIONS
+      end
+    end
 
     def register
-      if ::ActiveRecord::VERSION::MAJOR >= 4
-        ActiveRecord::Associations::Builder::Association.valid_options.concat(OPTIONS)
+      if ::ActiveRecord::VERSION::MAJOR >= 5
+        ActiveRecord::Associations::Builder::Association.extensions << AssociationBuilderExtension
       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
+        ActiveRecord::Associations::Builder::Association.valid_options.concat(OPTIONS)
       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
 

data/lib/goldiloader/compatibility.rb

@@ -2,21 +2,33 @@
 
 module Goldiloader
   module Compatibility
+    ACTIVE_RECORD_VERSION = ::Gem::Version.new(::ActiveRecord::VERSION::STRING)
+    PRE_RAILS_5_2 = ACTIVE_RECORD_VERSION < ::Gem::Version.new('5.2.0')
+    POST_RAILS_5_1_4 = ACTIVE_RECORD_VERSION > ::Gem::Version.new('5.1.5')
+    PRE_RAILS_5_1_5 = ACTIVE_RECORD_VERSION < ::Gem::Version.new('5.1.5')
+    FROM_EAGER_LOADABLE = ACTIVE_RECORD_VERSION >= ::Gem::Version.new('5.1.5') ||
+      (ACTIVE_RECORD_VERSION >= ::Gem::Version.new('5.0.7') && ACTIVE_RECORD_VERSION < ::Gem::Version.new('5.1.0'))
+    GROUP_EAGER_LOADABLE = FROM_EAGER_LOADABLE
 
-    MASS_ASSIGNMENT_SECURITY = ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity)
-    ASSOCIATION_FINDER_SQL = ::Gem::Version.new(::ActiveRecord::VERSION::STRING) < ::Gem::Version.new('4.1')
-    UNSCOPE_QUERY_METHOD = ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new('4.1')
+    def self.rails_4?
+      ::ActiveRecord::VERSION::MAJOR == 4
+    end
+
+    def self.rails_5_0?
+      ::ActiveRecord::VERSION::MAJOR == 5 && ::ActiveRecord::VERSION::MINOR == 0
+    end
 
-    def self.mass_assignment_security_enabled?
-      MASS_ASSIGNMENT_SECURITY
+    # See https://github.com/rails/rails/pull/32375
+    def self.destroyed_model_associations_eager_loadable?
+      PRE_RAILS_5_2
     end
 
-    def self.association_finder_sql_enabled?
-      ASSOCIATION_FINDER_SQL
+    def self.from_eager_loadable?
+      FROM_EAGER_LOADABLE
     end
 
-    def self.unscope_query_method_enabled?
-      UNSCOPE_QUERY_METHOD
+    def self.group_eager_loadable?
+      GROUP_EAGER_LOADABLE
     end
   end
 end

data/lib/goldiloader/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Goldiloader
-  VERSION = '0.0.9'
+  VERSION = '2.1.2'.freeze
 end