ar_lazy_preload 0.2.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a265f11a7c21888ebe4ac60ccce4ab42bf56ff8527217fa8946013df0c2b0324
-  data.tar.gz: ce5ed84890259cff5d994a6618fc8017af7e46dc6acb974ef44ec5cc183e494f
+  metadata.gz: 302e5031cc0d1046c7ef7400dca6767fb13e4f8e68ba98a7cfa20b648f64d60a
+  data.tar.gz: 40cc089d2e4863636d21f13bc9273f0c1341c209275d9162e6ce3ecad05c7e24
 SHA512:
-  metadata.gz: 0e7220676078a6a8fb0ed8b93e7eeb81260d20ce692177466dfa97e6ee8915fd56bd524fbac81b039f48ef6ba43023d9838235d6540f0518de73053395ca7ae1
-  data.tar.gz: 35280832594c531085e7d51047282852615029d4b019532cf00e098c069f85f98a4bfa9cc85f54866baa039c9124346420aa989919161a465d53dc2a873db473
+  metadata.gz: 00b77bb2a441ad78f74d96776d36073dbdcc29d811d98de5430ec750217c4f6d8bbf103465debd67c67fd3d86a296f8ab39d2d3e098f193fb348657d0d38c30f
+  data.tar.gz: 0e06520adf62f0bb9f0a1bb7b6d9d667b4478b206a4ffcb1e7c40efd2314d7d0205e72cc27bbb214a1a93e6a3d4a5cd5c5def11d458dfcb3054bd4240162c818

data/README.md

@@ -1,67 +1,73 @@
-[![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:
+## Auto preloading
 
-```sql
-SELECT * FROM users LIMIT 10
+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
+ArLazyPreload.config.auto_preload = true
 ```
 
-However, when we try to load 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:
 
 ```ruby
-users.map(&:posts)
+users.first.skip_preload.posts # => SELECT * FROM posts WHERE user_id = ?
 ```
 
-there will be one more request for posts:
+### Relation auto preloading
+
+Another alternative for auto preloading is using relation `#preload_associations_lazily` method
 
-```sql
-SELECT * FROM posts WHERE user_id in (...)
+```ruby
+posts = User.preload_associations_lazily.flat_map(&:posts)
+# => SELECT * FROM users LIMIT 10
+# => SELECT * FROM posts WHERE user_id in (...)
 ```
 
-## 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/base.rb

@@ -5,10 +5,17 @@ module ArLazyPreload
   module Base
     def self.included(base)
       base.class.delegate :lazy_preload, to: :all
+      base.class.delegate :preload_associations_lazily, to: :all
     end
 
     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/active_record/relation.rb

@@ -5,6 +5,8 @@ require "ar_lazy_preload/context"
 module ArLazyPreload
   # ActiveRecord::Relation patch with lazy preloading support
   module Relation
+    attr_writer :preloads_associations_lazily
+
     # Enhanced #load method will check if association has not been loaded yet and add a context
     # for lazy preloading to loaded each record
     def load
@@ -13,12 +15,25 @@ module ArLazyPreload
       if need_context
         Context.register(
           records: ar_lazy_preload_records,
-          association_tree: lazy_preload_values
+          association_tree: lazy_preload_values,
+          auto_preload: preloads_associations_lazily?
         )
       end
       result
     end
 
+    # Lazily autoloads all associations. For example:
+    #
+    #   users = User.preload_associations_lazily
+    #   users.each do |user|
+    #     user.posts.flat_map {|post| post.comments.map(&:id)}
+    #   end
+    #
+    # Same effect can be achieved by User.lazy_preload(posts: :comments)
+    def preload_associations_lazily
+      spawn.tap { |relation| relation.preloads_associations_lazily = true }
+    end
+
     # Specify relationships to be loaded lazily when association is loaded for the first time. For
     # example:
     #
@@ -56,6 +71,10 @@ module ArLazyPreload
       @records
     end
 
+    def preloads_associations_lazily?
+      @preloads_associations_lazily ||= false
+    end
+
     attr_writer :lazy_preload_values
   end
 end

data/lib/ar_lazy_preload/associated_context_builder.rb

@@ -23,23 +23,27 @@ module ArLazyPreload
 
     # Takes all the associated records for the records, attached to the :parent_context and creates
     # a preloading context for them
-    def perform
+    def perform # rubocop:disable Metrics/MethodLength
       associated_records = parent_context.records.flat_map do |record|
         next if record.nil?
 
-        record_association = record.public_send(association_name)
+        record_association = record.association(association_name)
         reflection = reflection_cache[record.class]
-        reflection.collection? ? record_association.target : record_association
+        reflection.collection? ? record_association.target : record_association.reader
       end
 
-      Context.register(records: associated_records, association_tree: child_association_tree)
+      Context.register(
+        records: associated_records,
+        association_tree: child_association_tree,
+        auto_preload: parent_context.auto_preload?
+      )
     end
 
     private
 
     def child_association_tree
       # `association_tree` is unnecessary when auto preload is enabled
-      return nil if ArLazyPreload.config.auto_preload?
+      return nil if parent_context.auto_preload?
 
       AssociationTreeBuilder.new(parent_context.association_tree).subtree_for(association_name)
     end

data/lib/ar_lazy_preload/context.rb

@@ -7,10 +7,10 @@ require "ar_lazy_preload/contexts/lazy_preload_context"
 module ArLazyPreload
   class Context
     # Initiates lazy preload context for given records
-    def self.register(records:, association_tree:)
+    def self.register(records:, association_tree:, auto_preload: false)
       return if records.empty?
 
-      if ArLazyPreload.config.auto_preload?
+      if ArLazyPreload.config.auto_preload? || auto_preload
         Contexts::AutoPreloadContext.new(records: records)
       elsif association_tree.any?
         Contexts::LazyPreloadContext.new(

data/lib/ar_lazy_preload/contexts/auto_preload_context.rb

@@ -4,6 +4,10 @@ module ArLazyPreload
   module Contexts
     # This class is responsible for automatic association preloading
     class AutoPreloadContext < BaseContext
+      def auto_preload?
+        true
+      end
+
       protected
 
       def association_needs_preload?(_association_name)

data/lib/ar_lazy_preload/contexts/base_context.rb

@@ -15,6 +15,7 @@ module ArLazyPreload
       def initialize(records:)
         @records = records.dup
         @records.compact!
+        @records.uniq!
         @records.each { |record| record.lazy_preload_context = self }
       end
 
@@ -27,6 +28,10 @@ module ArLazyPreload
         perform_preloading(association_name)
       end
 
+      def auto_preload?
+        false
+      end
+
       protected
 
       def association_needs_preload?(_association_name)

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.6"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_lazy_preload
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.4.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-04 00:00:00.000000000 Z
+date: 2020-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -164,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
@@ -195,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