ar_lazy_preload 0.2.5 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7060cc83164f3fff3a468514246ecbb5799accc1999dab8581c97db4d10f016a
-  data.tar.gz: 98075d278f0d04fa68ae9b31ddc60e0348b6a896460f512bc27195113095e700
+  metadata.gz: 69e0b3d4a8e8ac0c7c3824058347406f2ede573183f085b40acfd288e2b43014
+  data.tar.gz: d47fa44acb9b48181ac97c4c77138977375e1f593b4eaee4673314895836220f
 SHA512:
-  metadata.gz: aad5db14a66fb29fa11cfbd2968e2b3dbd54110ee51f89d95ca6a5c9538125c46732a03d7d4539f3b1c251b2ae6a5c4c986b3a677d93bd76d6384c6e843c11bb
-  data.tar.gz: 482285553c6d4b1057e0d5ee173eef21f14a7e5c5214c093614ee3730677d3c32f0039b5b387da4b05023713b7868ae75b22d23cf18edd0200f1176fd6b78b4a
+  metadata.gz: 73f6f5dd9b745e262d5e2e1e6532f266c65eda63282938e2b08838cbb1bf4e161df8a38d208c436714967d13ef2579a6398c492b3690f98d5d9a082169d93065
+  data.tar.gz: 5f084968e4c8aacdf438ab08f94e2768f9090185e91c1ce4e9f7841558d0541b42f8e3b9926df85191d634b01cbcb1aab9e7702b77a2eb438cf0b732017e9322

data/README.md

@@ -1,67 +1,63 @@
-[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/activerecord-lazy-preload.html)
-[![Gem Version](https://badge.fury.io/rb/ar_lazy_preload.svg)](https://rubygems.org/gems/ar_lazy_preload)
-[![Build Status](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload.svg?branch=master)](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload)
-[![Maintainability](https://api.codeclimate.com/v1/badges/00d04595661820dfba80/maintainability)](https://codeclimate.com/github/DmitryTsepelev/ar_lazy_preload/maintainability)
-[![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/ar_lazy_preload/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/ar_lazy_preload?branch=master)
+# ArLazyPreload [![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/activerecord-lazy-preload.html) [![Gem Version](https://badge.fury.io/rb/ar_lazy_preload.svg)](https://rubygems.org/gems/ar_lazy_preload) [![Build Status](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload.svg?branch=master)](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload) [![Maintainability](https://api.codeclimate.com/v1/badges/00d04595661820dfba80/maintainability)](https://codeclimate.com/github/DmitryTsepelev/ar_lazy_preload/maintainability) [![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/ar_lazy_preload/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/ar_lazy_preload?branch=master)
 
-# ArLazyPreload
+**ArLazyPreload** is a gem that brings association lazy load functionality to your Rails applications. There is a number of built-in methods to solve [N+1 problem](https://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations), but sometimes a list of associations to preload is not obvious–this is when you can get most of this gem.
 
-<a href="https://evilmartians.com/?utm_source=ar_lazy_preload">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+- **Simple**. The only thing you need to change is to use `#lazy_preload` instead of `#includes`, `#eager_load` or `#preload`
+- **Fast**. Take a look at [benchmarks](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload) (`TASK=bench` and `TASK=memory`)
+- **Perfect fit for GraphQL**. Define a list of associations to load at the top-level resolver and let the gem do its job
+- **Auto-preload support**. If you don't want to specify the association list–set `ArLazyPreload.config.auto_preload` to `true`
 
-Lazy loading associations for the ActiveRecord models. `#includes`, `#eager_load` and `#preload` are built-in methods to avoid N+1 problem, but sometimes when DB request is made we don't know what associations we are going to need later (for instance when your API allows client to define a list of loaded associations dynamically). The only possible solution for such cases is to load _all_ the associations we might need, but it can be a huge overhead.
+<p align="center">
+  <a href="https://evilmartians.com/?utm_source=ar_lazy_preload">
+    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+  </a>
+</p>
 
-This gem allows to set up _lazy_ preloading for associations - it won't load anything until association is called for a first time, but when it happens - it loads all the associated records for all records from the initial relation in a single query.
+## Why should I use it?
 
-## Installation
-
-Add this line to your application's Gemfile, and you're all set:
+Lazy loading is super helpful when the list of associations to load is determined dynamically. For instance, in GraphQL this list comes from the API client, and you'll have to inspect the selection set to find out what associations are going to be used.
 
-```ruby
-gem "ar_lazy_preload"
-```
+This gem uses a different approach: it won't load anything until the association is called for a first time. When it happens–it loads all the associated records for all records from the initial relation in a single query.
 
 ## Usage
 
-For example, if we define the following relation
+Let's try `#lazy_preload` in action! The following code will perform a single SQL request (because we've never accessed posts):
 
 ```ruby
-users = User.lazy_preload(:posts).limit(10)
+users = User.lazy_preload(:posts).limit(10)  # => SELECT * FROM users LIMIT 10
+users.map(&:first_name)
 ```
 
-and use it in the following way
+However, when we try to load posts, there will be one more request for posts:
 
 ```ruby
-users.map(&:first_name)
+users.map(&:posts) # => SELECT * FROM posts WHERE user_id in (...)
 ```
 
-there will be one query because we've never accessed posts:
-
-```sql
-SELECT * FROM users LIMIT 10
-```
+## Auto preloading
 
-However, when we try to load posts
+If you want the gem to be even lazier–you can configure it to load all the associations lazily without specifying them explicitly. To do that you'll need to change the configuration in the following way:
 
 ```ruby
-users.map(&:posts)
+ArLazyPreload.config.auto_preload = true
 ```
 
-there will be one more request for posts:
+After that there is no need to call `#lazy_preload` on the association, everything would be loaded lazily.
+
+If you want to turn automatic preload off for a specific record, you can call `.skip_preload` before any associations method:
 
-```sql
-SELECT * FROM posts WHERE user_id in (...)
+```ruby
+users.first.skip_preload.posts # => SELECT * FROM posts WHERE user_id = ?
 ```
 
-## Auto preloading
+## Installation
 
-If you want the gem to be even more lazy - you can configure it to load all the associations lazily without specifying them explicitly. In order to do that you'll need to change the configuration in the following way:
+Add this line to your application's Gemfile, and you're all set:
 
 ```ruby
-ArLazyPreload.config.auto_preload = true
+gem "ar_lazy_preload"
 ```
 
-After that there is no need to call `lazy_preload` on the association, everything would be loaded lazily.
-
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -13,3 +13,13 @@ if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
 else
   task default: [:rubocop, :spec]
 end
+
+task :bench do
+  cmd = %w[bundle exec ruby benchmark/main.rb]
+  exit system(*cmd)
+end
+
+task :memory do
+  cmd = %w[bundle exec ruby benchmark/memory.rb]
+  exit system(*cmd)
+end

data/lib/ar_lazy_preload/active_record/association_relation.rb

@@ -6,16 +6,21 @@ module ArLazyPreload
   module AssociationRelation
     def initialize(*args)
       super(*args)
+      setup_preloading_context unless ArLazyPreload.config.auto_preload?
+    end
+
+    delegate :owner, :reflection, to: :proxy_association
+    delegate :lazy_preload_context, to: :owner
 
-      context = owner.lazy_preload_context
-      return if context.nil?
+    private
 
-      association_tree_builder = AssociationTreeBuilder.new(context.association_tree)
+    def setup_preloading_context
+      return if lazy_preload_context.nil?
+
+      association_tree_builder = AssociationTreeBuilder.new(lazy_preload_context.association_tree)
       subtree = association_tree_builder.subtree_for(reflection.name)
 
       lazy_preload!(subtree)
     end
-
-    delegate :owner, :reflection, to: :proxy_association
   end
 end

data/lib/ar_lazy_preload/active_record/base.rb

@@ -10,5 +10,11 @@ module ArLazyPreload
     attr_accessor :lazy_preload_context
 
     delegate :try_preload_lazily, to: :lazy_preload_context, allow_nil: true
+
+    def skip_preload
+      lazy_preload_context&.records&.delete(self)
+      self.lazy_preload_context = nil
+      self
+    end
   end
 end

data/lib/ar_lazy_preload/active_record/collection_association.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # ActiveRecord::CollectionAssociation patch with a hook for lazy preloading
+  module CollectionAssociation
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def ids_reader
+      return super if owner.lazy_preload_context.blank?
+
+      primary_key = reflection.association_primary_key.to_sym
+      if loaded?
+        target.map(&primary_key)
+      elsif !target.empty?
+        load_target.map(&primary_key)
+      else
+        @association_ids ||= reader.map(&primary_key)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  end
+end

data/lib/ar_lazy_preload/active_record/merger.rb

@@ -8,7 +8,7 @@ module ArLazyPreload
     def merge
       result = super
 
-      if other.lazy_preload_values
+      if other.lazy_preload_values.any?
         if other.klass == relation.klass
           merge_lazy_preloads
         else

data/lib/ar_lazy_preload/associated_context_builder.rb

@@ -24,11 +24,13 @@ module ArLazyPreload
     # Takes all the associated records for the records, attached to the :parent_context and creates
     # a preloading context for them
     def perform
-      records_by_class = parent_context.records.group_by(&:class)
+      associated_records = parent_context.records.flat_map do |record|
+        next if record.nil?
 
-      associated_records = records_by_class.map do |klass, klass_records|
-        associated_records_for(klass, klass_records)
-      end.flatten
+        record_association = record.association(association_name)
+        reflection = reflection_cache[record.class]
+        reflection.collection? ? record_association.target : record_association.reader
+      end
 
       Context.register(records: associated_records, association_tree: child_association_tree)
     end
@@ -36,13 +38,16 @@ module ArLazyPreload
     private
 
     def child_association_tree
+      # `association_tree` is unnecessary when auto preload is enabled
+      return nil if ArLazyPreload.config.auto_preload?
+
       AssociationTreeBuilder.new(parent_context.association_tree).subtree_for(association_name)
     end
 
-    def associated_records_for(klass, records)
-      record_associations = records.map { |record| record.send(association_name) }
-      reflection = klass.reflect_on_association(association_name)
-      reflection.collection? ? record_associations.map(&:target).flatten : record_associations
+    def reflection_cache
+      @reflection_cache ||= Hash.new do |hash, klass|
+        hash[klass] = klass.reflect_on_association(association_name)
+      end
     end
   end
 end

data/lib/ar_lazy_preload/association_tree_builder.rb

@@ -8,9 +8,6 @@ module ArLazyPreload
     attr_reader :association_tree
 
     def initialize(association_tree)
-      # Since `association_tree` can be an array or a single hash
-      # Converting it to an array is easier for processing
-      # like jquery
       @association_tree =
         case association_tree
         when Array
@@ -18,8 +15,7 @@ module ArLazyPreload
         when Hash
           [association_tree]
         else
-          raise NotImplementedError,
-                "unexpected association_tree with class #{association_tree.class}"
+          raise ArgumentError, "unexpected association_tree with class #{association_tree.class}"
         end.select { |node| node.is_a?(Hash) }
     end
 
@@ -31,7 +27,7 @@ module ArLazyPreload
 
     def subtree_cache
       @subtree_cache ||= Hash.new do |hash, association|
-        hash[association] = association_tree.map { |node| node[association] }.flatten
+        hash[association] = association_tree.flat_map { |node| node[association] }
       end
     end
   end

data/lib/ar_lazy_preload/context.rb

@@ -1,76 +1,23 @@
 # frozen_string_literal: true
 
-require "set"
-require "ar_lazy_preload/associated_context_builder"
+require "ar_lazy_preload/contexts/base_context"
+require "ar_lazy_preload/contexts/auto_preload_context"
+require "ar_lazy_preload/contexts/lazy_preload_context"
 
 module ArLazyPreload
-  # This class is responsible for holding a connection between a list of ActiveRecord::Base objects
-  # which have been loaded by the same instance of ActiveRecord::Relation. It also contains a tree
-  # of associations, which were requested to be loaded lazily.
-  # Calling #preload_association method will cause loading of ALL associated objects for EACH
-  # ecord when requested association is found in the association tree.
   class Context
     # Initiates lazy preload context for given records
     def self.register(records:, association_tree:)
-      return if records.empty? || association_tree.empty? && !ArLazyPreload.config.auto_preload?
-
-      ArLazyPreload::Context.new(records: records, association_tree: association_tree)
-    end
-
-    attr_reader :records, :association_tree
-
-    # :records - array of ActiveRecord instances
-    # :association_tree - list of symbols or hashes representing a tree of preloadable associations
-    def initialize(records:, association_tree:)
-      @records = records.compact
-      @association_tree = association_tree
-
-      @records.each { |record| record.lazy_preload_context = self }
-    end
-
-    # This method checks if the association is present in the association_tree and preloads for all
-    # objects in the context it if needed.
-    def try_preload_lazily(association_name)
-      return unless association_needs_preload?(association_name)
-
-      preloader.preload(records, association_name)
-      AssociatedContextBuilder.prepare(parent_context: self, association_name: association_name)
-      # Our tracking of loading state
-      # Otherwise `#preload` will be called many times even when association is loaded
-      mark_association_as_loaded(association_name)
-    end
-
-    private
-
-    def association_needs_preload?(association_name, node_tree = association_tree)
-      # Check whether association loading state
-      # to avoid calling preload unnecessarily
-      return false if association_loaded?(association_name)
-      return true if ArLazyPreload.config.auto_preload?
-
-      node_tree.any? do |node|
-        if node.is_a?(Symbol)
-          node == association_name
-        elsif node.is_a?(Hash)
-          node.key?(association_name)
-        end
+      return if records.empty?
+
+      if ArLazyPreload.config.auto_preload?
+        Contexts::AutoPreloadContext.new(records: records)
+      elsif association_tree.any?
+        Contexts::LazyPreloadContext.new(
+          records: records,
+          association_tree: association_tree
+        )
       end
     end
-
-    def mark_association_as_loaded(association_name)
-      loaded_association_names.add(association_name)
-    end
-
-    def association_loaded?(association_name)
-      loaded_association_names.include?(association_name)
-    end
-
-    def loaded_association_names
-      @loaded_association_names ||= Set.new
-    end
-
-    def preloader
-      @preloader ||= ActiveRecord::Associations::Preloader.new
-    end
   end
 end

data/lib/ar_lazy_preload/contexts/auto_preload_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  module Contexts
+    # This class is responsible for automatic association preloading
+    class AutoPreloadContext < BaseContext
+      protected
+
+      def association_needs_preload?(_association_name)
+        true
+      end
+    end
+  end
+end

data/lib/ar_lazy_preload/contexts/base_context.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "set"
+require "ar_lazy_preload/associated_context_builder"
+
+module ArLazyPreload
+  module Contexts
+    # This is a base context class, which is responsible for holding a connection between a list of
+    # ActiveRecord::Base objects which have been loaded by the same instance of
+    # ActiveRecord::Relation.
+    class BaseContext
+      attr_reader :records
+
+      # :records - array of ActiveRecord instances
+      def initialize(records:)
+        @records = records.dup
+        @records.compact!
+        @records.uniq!
+        @records.each { |record| record.lazy_preload_context = self }
+      end
+
+      # This method checks if the association should be loaded and preloads it for all
+      # objects in the context it if needed.
+      def try_preload_lazily(association_name)
+        return if association_loaded?(association_name) ||
+                  !association_needs_preload?(association_name)
+
+        perform_preloading(association_name)
+      end
+
+      protected
+
+      def association_needs_preload?(_association_name)
+        raise NotImplementedError
+      end
+
+      private
+
+      def perform_preloading(association_name)
+        preloader.preload(records, association_name)
+        loaded_association_names.add(association_name)
+
+        AssociatedContextBuilder.prepare(
+          parent_context: self,
+          association_name: association_name
+        )
+      end
+
+      def association_loaded?(association_name)
+        loaded_association_names.include?(association_name)
+      end
+
+      def loaded_association_names
+        @loaded_association_names ||= Set.new
+      end
+
+      def preloader
+        @preloader ||= ActiveRecord::Associations::Preloader.new
+      end
+    end
+  end
+end

data/lib/ar_lazy_preload/contexts/lazy_preload_context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  module Contexts
+    # This class is responsible for lazy preloading. It contains a tree of associations, which were
+    # requested to be loaded lazily.
+    class LazyPreloadContext < BaseContext
+      attr_reader :association_tree
+
+      # :records - array of ActiveRecord instances
+      # :association_tree - list of symbols or hashes representing a tree of preloadable
+      # associations
+      def initialize(records:, association_tree:)
+        @association_tree = association_tree
+
+        super(records: records)
+      end
+
+      protected
+
+      def association_needs_preload?(association_name)
+        association_tree.any? do |node|
+          case node
+          when Symbol
+            node == association_name
+          when Hash
+            node.key?(association_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ar_lazy_preload/railtie.rb

@@ -3,6 +3,7 @@
 require "ar_lazy_preload/active_record/base"
 require "ar_lazy_preload/active_record/relation"
 require "ar_lazy_preload/active_record/association"
+require "ar_lazy_preload/active_record/collection_association"
 require "ar_lazy_preload/active_record/merger"
 require "ar_lazy_preload/active_record/association_relation"
 require "ar_lazy_preload/active_record/collection_proxy"
@@ -22,6 +23,7 @@ module ArLazyPreload
           ActiveRecord::Associations::Association
         ].each { |klass| klass.prepend(Association) }
 
+        ActiveRecord::Associations::CollectionAssociation.prepend(CollectionAssociation)
         ActiveRecord::Associations::CollectionProxy.prepend(CollectionProxy)
       end
     end

data/lib/ar_lazy_preload/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArLazyPreload
-  VERSION = "0.2.5"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ar_lazy_preload
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.2
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-29 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  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: lazy_preload implementation for ActiveRecord models
 email:
 - dmitry.a.tsepelev@gmail.com
@@ -136,6 +164,7 @@ files:
 - lib/ar_lazy_preload/active_record/association.rb
 - lib/ar_lazy_preload/active_record/association_relation.rb
 - lib/ar_lazy_preload/active_record/base.rb
+- lib/ar_lazy_preload/active_record/collection_association.rb
 - lib/ar_lazy_preload/active_record/collection_proxy.rb
 - lib/ar_lazy_preload/active_record/merger.rb
 - lib/ar_lazy_preload/active_record/relation.rb
@@ -143,6 +172,9 @@ files:
 - lib/ar_lazy_preload/association_tree_builder.rb
 - lib/ar_lazy_preload/configuration.rb
 - lib/ar_lazy_preload/context.rb
+- lib/ar_lazy_preload/contexts/auto_preload_context.rb
+- lib/ar_lazy_preload/contexts/base_context.rb
+- lib/ar_lazy_preload/contexts/lazy_preload_context.rb
 - lib/ar_lazy_preload/railtie.rb
 - lib/ar_lazy_preload/version.rb
 homepage: https://github.com/DmitryTsepelev/ar_lazy_preload
@@ -164,8 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: lazy_preload implementation for ActiveRecord models