goldiloader 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fce4ef7cebc4da5f8fb6cd2187305e0545199a1
-  data.tar.gz: 644ebffadf9f5e1bcf1a8c15893a10b23278c97e
+  metadata.gz: 5c786bf07ce1fedb7741246eda75430f8360617e
+  data.tar.gz: 855321310698182f6016a12556c9010bf2f8075c
 SHA512:
-  metadata.gz: 2e2aba9114d41066e38d4e1857795b5da1f16083af7940318529da7a4fd10aa45ad6e6417d180562f6dcb278ee36baac34e216a9f0e8f4f7a62f3564b91d2e76
-  data.tar.gz: 8b5cb28cda6c254f774016e69bef9774b022c1ce60c3be2f8b568f31e651259cf7356800badef7e94a3ff60230e463383f30823b419ffba10c257eb29fb4417b
+  metadata.gz: bea207299074113890d1d278f5f83681fdb542b5b68b6006ce62eb58857c421b00181c5ba8a6dcd6c99e5043667b8dc710c189cbb6c5ad8805f99565143183b2
+  data.tar.gz: ca685d4a21ddcdfde6bc0bad6dc3894cdc7bc6cc850a09388014c462a9c3fdd63877f8469c90df69cd90138ca8dbb2c175b2df61f33fa427352c09c234e2b074

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,158 +26,157 @@ module Goldiloader
       super
     end
   end
-end
+  ::ActiveRecord::Base.include(::Goldiloader::BasePatch)
 
-ActiveRecord::Base.send(:include, Goldiloader::AutoIncludableModel)
+  module RelationPatch
+    def exec_queries
+      return super if loaded? || !auto_include_value
 
-ActiveRecord::Relation.class_eval do
+      models = super
+      Goldiloader::AutoIncludeContext.register_models(models, eager_load_values)
+      models
+    end
 
-  def exec_queries_with_auto_include(&block)
-    return exec_queries_without_auto_include(&block) if loaded?
+    def auto_include(auto_include = true)
+      spawn.auto_include!(auto_include)
+    end
 
-    models = exec_queries_without_auto_include(&block)
-    Goldiloader::AutoIncludeContext.register_models(models, eager_load_values)
-    models
-  end
+    def auto_include!(auto_include = true)
+      self.auto_include_value = auto_include
+      self
+    end
 
-  Goldiloader::Compatibility.alias_method_chain self, :exec_queries, :auto_include
-end
+    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
 
-ActiveRecord::Associations::Association.class_eval do
+    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)
 
-  class_attribute :default_auto_include, :default_fully_load
-  self.default_auto_include = true
-  self.default_fully_load = false
+  module MergerPatch
+    private
 
-  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 merge_single_values
+      relation.auto_include_value = other.auto_include_value
+      super
+    end
   end
+  ActiveRecord::Relation::Merger.prepend(::Goldiloader::MergerPatch)
 
-  def fully_load?
-    !loaded? && options.fetch(:fully_load) { self.class.default_fully_load }
-  end
+  module AssociationPatch
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_fully_load
+      self.default_fully_load = false
+    end
 
-  private
+    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
+
+    def fully_load?
+      !loaded? && options.fetch(:fully_load) { self.class.default_fully_load }
+    end
 
-  def eager_loadable?
-    association_info = Goldiloader::AssociationInfo.new(self)
-    !association_info.limit? &&
+    private
+
+    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? &&
-        (Goldiloader::Compatibility.unscoped_eager_loadable? || !association_info.unscope?) &&
-        (Goldiloader::Compatibility.joins_eager_loadable? || !association_info.joins?) &&
-        !association_info.instance_dependent?
-  end
+        !association_info.instance_dependent? &&
+        association_info.auto_include?
+    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 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)
 
-end
-
-ActiveRecord::Associations::SingularAssociation.class_eval do
-
-  private
+  module SingularAssociationPatch
+    private
 
-  def find_target_with_auto_include(*args)
-    load_with_auto_include(:find_target, *args)
+    def find_target(*args)
+      load_with_auto_include { super }
+    end
   end
+  ::ActiveRecord::Associations::SingularAssociation.prepend(::Goldiloader::SingularAssociationPatch)
 
-  Goldiloader::Compatibility.alias_method_chain self, :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)
+  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
 
-    Goldiloader::Compatibility.alias_method_chain self, method, :fully_load
-  end
+    association_methods.each do |method|
+      define_method(method) do |*args, &block|
+        load_target if fully_load?
+        super(*args, &block)
+      end
+    end
 
-  private
+    def load_target(*args)
+      load_with_auto_include { super }
+    end
 
-  def load_target_with_auto_include(*args)
-    load_with_auto_include(:load_target, *args)
+    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)
 
-  Goldiloader::Compatibility.alias_method_chain self, :load_target, :auto_include
-
-end
-
-[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?
-    end
-  end
-end
-
-# In Rails >= 4.1 has_and_belongs_to_many associations create a has_many associations
-# under the covers so we need to make sure to propagate the auto_include option to that
-# association
-if Goldiloader::Compatibility::ACTIVE_RECORD_VERSION >= ::Gem::Version.new('4.1')
-  ActiveRecord::Associations::ClassMethods.class_eval do
-    
-    def has_and_belongs_to_many_with_auto_include_option(name, scope = nil, options = {}, &extension)
-      if scope.is_a?(Hash)
-        options = scope
-        scope = nil
+  ::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
-
-      result = has_and_belongs_to_many_without_auto_include_option(name, scope, options, &extension)
-      if options.include?(:auto_include)
-        _reflect_on_association(name).options[:auto_include] = options[:auto_include]
-      end
-      result
-    end
-
-    Goldiloader::Compatibility.alias_method_chain self, :has_and_belongs_to_many, :auto_include_option
-  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).
-    if args.empty? && @association.fully_load?
-      size > 0
-    elsif Goldiloader::Compatibility::RAILS_3
-      scoped.exists?(*args)
-    else
-      scope.exists?(*args)
     end
   end
+  ::ActiveRecord::Associations::CollectionProxy.prepend(::Goldiloader::CollectionProxyPatch)
 end

data/lib/goldiloader/association_info.rb

@@ -7,119 +7,34 @@ module Goldiloader
       @association = association
     end
 
-    def finder_sql?
-      Goldiloader::Compatibility.association_finder_sql_enabled? &&
-        association_options[:finder_sql].present?
-    end
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      delegate :association_scope, :reflection, to: :@association
-
-      def read_only?
-        association_scope && association_scope.readonly_value.present?
-      end
-
-      def offset?
-        association_scope && association_scope.offset_value.present?
-      end
-
-      def limit?
-        association_scope && association_scope.limit_value.present?
-      end
-
-      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?
-        return false unless association_scope
-
-        num_joins = association_scope.joins_values.size
-        if ActiveRecord::VERSION::MAJOR >= 5
-          num_joins += association_scope.left_joins_values.size + association_scope.left_outer_joins.size
-        end
-        # Yuck - Through associations will always have a join for *each* 'through' table
-        num_joins - 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
+    delegate :association_scope, :reflection, to: :@association
 
-      def joins?
-        # Rails 3 didn't support joins for associations
-        false
-      end
+    def offset?
+      association_scope && association_scope.offset_value.present?
+    end
 
-      def uniq?
-        association_options[:uniq]
-      end
+    def limit?
+      association_scope && association_scope.limit_value.present?
+    end
 
-      def instance_dependent?
-        # Rails 3 didn't support this
-        false
-      end
+    def auto_include?
+      association_scope.nil? || association_scope.auto_include_value
+    end
 
-      def unscope?
-        # Rails 3 didn't support this
-        false
+    def from?
+      if ActiveRecord::VERSION::MAJOR >= 5
+        association_scope && association_scope.from_clause.present?
+      else
+        association_scope && association_scope.from_value.present?
       end
     end
 
-    private
+    def group?
+      association_scope && association_scope.group_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 for Rails < 4.2.0 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,7 +4,7 @@ module Goldiloader
   module AssociationOptions
     extend self
 
-    OPTIONS = [:auto_include, :fully_load].freeze
+    OPTIONS = [:fully_load].freeze
 
     # This is only used in Rails 5+
     module AssociationBuilderExtension
@@ -20,30 +20,12 @@ module Goldiloader
     def register
       if ::ActiveRecord::VERSION::MAJOR >= 5
         ActiveRecord::Associations::Builder::Association.extensions << AssociationBuilderExtension
-      elsif ::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
+        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,61 +2,14 @@
 
 module Goldiloader
   module Compatibility
-
     ACTIVE_RECORD_VERSION = ::Gem::Version.new(::ActiveRecord::VERSION::STRING)
-    RAILS_3 = ACTIVE_RECORD_VERSION < ::Gem::Version.new('4')
-    MASS_ASSIGNMENT_SECURITY = RAILS_3 || defined?(::ActiveRecord::MassAssignmentSecurity)
-    ASSOCIATION_FINDER_SQL = ACTIVE_RECORD_VERSION < ::Gem::Version.new('4.1')
-    UNSCOPE_QUERY_METHOD = ACTIVE_RECORD_VERSION >= ::Gem::Version.new('4.1')
-    JOINS_EAGER_LOADABLE = ACTIVE_RECORD_VERSION >= ::Gem::Version.new('4.2')
-    UNSCOPED_EAGER_LOADABLE = ACTIVE_RECORD_VERSION >= ::Gem::Version.new('4.1.9')
-
-    def self.mass_assignment_security_enabled?
-      MASS_ASSIGNMENT_SECURITY
-    end
-
-    def self.association_finder_sql_enabled?
-      ASSOCIATION_FINDER_SQL
-    end
-
-    def self.unscope_query_method_enabled?
-      UNSCOPE_QUERY_METHOD
-    end
-
-    def self.joins_eager_loadable?
-      # Associations with joins were not eager loadable prior to Rails 4.2 due to
-      # https://github.com/rails/rails/pull/17678
-      JOINS_EAGER_LOADABLE
-    end
 
-    def self.unscoped_eager_loadable?
-      # Unscoped associations weren't properly eager loaded until after Rails 4.1.9.
-      # See https://github.com/rails/rails/issues/11036.
-      UNSCOPED_EAGER_LOADABLE
+    def self.rails_4?
+      ::ActiveRecord::VERSION::MAJOR == 4
     end
 
-    # Copied from Rails since it is deprecated in Rails 5.0. Switch to using
-    # Module#prepend when we drop Ruby 1.9 support.
-    def self.alias_method_chain(klass, target, feature)
-      # Strip out punctuation on predicates, bang or writer methods since
-      # e.g. target?_without_feature is not a valid method name.
-      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-      yield(aliased_target, punctuation) if block_given?
-
-      with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
-      without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
-
-      klass.send(:alias_method, without_method, target)
-      klass.send(:alias_method, target, with_method)
-
-      case
-      when klass.public_method_defined?(without_method)
-        klass.send(:public, target)
-      when klass.protected_method_defined?(without_method)
-        klass.send(:protected, target)
-      when klass.private_method_defined?(without_method)
-        klass.send(:private, target)
-      end
+    def self.rails_5_0?
+      ::ActiveRecord::VERSION::MAJOR == 5 && ::ActiveRecord::VERSION::MINOR == 0
     end
   end
 end

data/lib/goldiloader/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: goldiloader
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Joel Turkel
@@ -14,42 +14,30 @@ dependencies:
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 3.2.22.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 3.2.22.2
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 3.2.22.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 3.2.22.2
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -110,30 +98,30 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -176,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="