n1_loader 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a365bb6b58a962185cd24033f6dd6cb98510712973dacdea4977a3121b64adc
-  data.tar.gz: d06031503475dc13f52acddb881931de5b7dd244acab6b46553d4a73c8efbd2d
+  metadata.gz: 8b9b61121f94d9dba30e969c1b9a3fa9c812292d618434a98262c90aef43e6cd
+  data.tar.gz: a1ecf5359a1a53200e354b30289566a437cf372c54ccf3f13c2e0adc2cb71640
 SHA512:
-  metadata.gz: 9172c4cd233739a0ebc379b3988037349d028020d5eb066642532f2b3da2a75d3faa34edd872aa5b5925eed91509c2c3a202e7a9aa448ca5020435b4f5e9c5a5
-  data.tar.gz: e74f92e69f47909b812adecb1aa7dc319c090a2ad865e89732a4ebdbbd378c02dbec28cc7ff5b0ff42262acf3a07e8deb8a4a949634d70c6d6c3986837a6ab5d
+  metadata.gz: 5c545cc2033dc8e75edddd5c948eed78fc1d965464522147841d30e3c6a02aebb0b6758d3f801b020c25d62618f7ae4bbb7ff11441748f798546351b1bf34d85
+  data.tar.gz: a60fa813399debf1ae9c8f839272a683c2a7f733ea392b4b1bd4169af55369a1d3be2fd8648a548e50093005e3d2df962437adf08f1f9fdf1338fa4ab6217df7

data/.circleci/config.yml

@@ -11,8 +11,8 @@ executors:
     docker:
       - image: circleci/ruby:<< parameters.tag >>
     environment:
-      - BUNDLE_JOBS: 4
-      - BUNDLE_RETRY: 3
+      BUNDLE_JOBS: 4
+      BUNDLE_RETRY: 3
     working_directory: ~/n1_loader
 
 jobs:
@@ -29,28 +29,49 @@ jobs:
     parameters:
       ruby-version:
         type: string
-      gemfile:
+      activerecord-gemfile:
         type: string
+      ar_lazy_preload-gemfile:
+        type: string
+    environment:
+      ACTIVERECORD_GEMFILE: << parameters.activerecord-gemfile >>
+      AR_LAZY_PRELOAD_GEMFILE: << parameters.ar_lazy_preload-gemfile >>
     executor:
       name: ruby
       tag: << parameters.ruby-version >>
     steps:
       - attach_workspace:
           at: ~/n1_loader
-      - run:
-          name: Use << parameters.gemfile >> as the Gemfile
-          command: bundle config --global gemfile << parameters.gemfile >>
       - run:
           name: Install the gems specified by the Gemfile
           command: bundle install
       - run:
-          name: Run RSpec
+          name: Run Core RSpec
           command: |
             bundle exec rspec --profile 10 \
                               --format RspecJunitFormatter \
-                              --out test_results/rspec.xml \
+                              --out test_results/core.xml \
                               --format progress \
-                              $(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)
+                              spec/n1_loader_spec.rb
+      - run:
+          name: Run ActiveRecord integration RSpec
+          command: |
+            bundle exec rspec --profile 10 \
+                              --format RspecJunitFormatter \
+                              --out test_results/activerecord-integration.xml \
+                              --format progress \
+                              spec/n1_loader_spec.rb \
+                              spec/activerecord_spec.rb
+      - run:
+          name: Run ActiveRecord integration RSpec
+          command: |
+            bundle exec rspec --profile 10 \
+                              --format RspecJunitFormatter \
+                              --out test_results/ar-lazy-preload-integration.xml \
+                              --format progress \
+                              spec/n1_loader_spec.rb \
+                              spec/activerecord_spec.rb \
+                              spec/ar_lazy_preload_spec.rb
       - store_test_results:
           path: test_results
 
@@ -80,22 +101,36 @@ workflows:
             parameters:
               ruby-version: [
                 "2.5",
-                "2.6",
                 "2.7",
-                "3.0",
                 "latest"
               ]
-              gemfile: [
-                "gemfiles/ar_5_latest.gemfile",
-                "gemfiles/ar_6_latest.gemfile"
+              activerecord-gemfile: [
+                "ar_5_latest",
+                "ar_6_latest"
+              ]
+              ar_lazy_preload-gemfile: [
+                "ar_lazy_preload_0.6.1",
+                "ar_lazy_preload_master"
               ]
             exclude:
-              - ruby-version: "3.0"
-                gemfile: "gemfiles/ar_5_latest.gemfile"
+              # Ruby 2.5 and AR Lazy Preload 1+
+              - ruby-version: "2.5"
+                activerecord-gemfile: "ar_5_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_master"
+
+              - ruby-version: "2.5"
+                activerecord-gemfile: "ar_6_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_master"
+
+              # AR 5 and ruby 3+
+              - ruby-version: "latest"
+                activerecord-gemfile: "ar_5_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_0.6.1"
               - ruby-version: "latest"
-                gemfile: "gemfiles/ar_5_latest.gemfile"
+                activerecord-gemfile: "ar_5_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_master"
 
-          name: << matrix.gemfile >>-build-ruby-<< matrix.ruby-version >>
+          name: ruby-<< matrix.ruby-version >>-<< matrix.activerecord-gemfile >>-<< matrix.ar_lazy_preload-gemfile >>
       - rubocop:
           requires:
             - checkout

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.2.0]
+
+- Introduce arguments support.
+
 ## [1.1.0] - 2021-12-27
 
 - Introduce `fulfill` method to abstract the storage.

data/Gemfile

@@ -4,3 +4,12 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in n1_loader.gemspec
 gemspec
+
+# Hack to make Github work with Circle CI job names with slashes
+gemfiles = []
+gemfiles << "activerecord-gemfiles/#{ENV["ACTIVERECORD_GEMFILE"]}.gemfile" if ENV["ACTIVERECORD_GEMFILE"]
+gemfiles << "ar_lazy_preload-gemfiles/#{ENV["AR_LAZY_PRELOAD_GEMFILE"]}.gemfile" if ENV["AR_LAZY_PRELOAD_GEMFILE"]
+
+gemfiles.each do |path|
+  eval(File.read(path)) # rubocop:disable Security/Eval
+end

data/README.md

@@ -14,6 +14,7 @@ It has many benefits:
 - it supports [shareable loaders](#shareable-loaders) between multiple classes
 - it supports [reloading](#reloading)
 - it supports optimized [single object loading](#optimized-single-case)
+- it supports [arguments](#arguments)
 - it has an integration with [ActiveRecord][5] which makes it brilliant ([example](#activerecord))
 - it has an integration with [ArLazyPreload][6] which makes it excellent ([example](#arlazypreload))
 
@@ -39,119 +40,115 @@ gem 'n1_loader', require: 'n1_loader/ar_lazy_preload'
 
 ## Usage
 
-**Supported Ruby version:** 2.5, 2.6, 2.7, 3.0, and latest.
-
 ```ruby
-class Example
+class User
   include N1Loader::Loadable
 
   # with inline loader
-  n1_loader :anything do |elements|
-    elements.each { |element| fulfill(element, [element]) }
-  end
-
-  # with custom loader
-  n1_loader :something, MyLoader
-end
-
-# Custom loader that can be shared with many classes
-class MyLoader < N1Loader::Loader
-  def perform(elements)
-    elements.each { |element| fulfill(element, [element]) }
+  n1_loader :orders_count do |users|
+    orders_per_user = Order.where(user: users).group(:user_id).count
+    
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
 # For single object
-ex = Example.new
-ex.anything 
+user = User.new
+user.orders_count 
 
 # For multiple objects without N+1
-objects = [Example.new, Example.new]
-N1Loader::Preloader.new(objects).preload(:anything)
-objects.map(&:anything)
+users = [User.new, User.new]
+N1Loader::Preloader.new(users).preload(:orders_count)
+users.map(&:orders_count)
 ```
 
 ### Lazy loading
 
 ```ruby
-class Example
+class User
   include N1Loader::Loadable
-  
-  n1_loader :anything do |elements|
-    elements.each { |element| fulfill(element, [element]) }
+
+  # with inline loader
+  n1_loader :orders_count do |users|
+    orders_per_user = Order.where(user: users).group(:user_id).count
+
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
-object = Example.new # => nothing was done for loading
-object.anything # => first time loading
+user = User.new # => nothing was done for loading
+user.orders_count # => first time loading
 
-objects = [Example.new, Example.new] # => nothing was done for loading
-N1Loader::Preloader.new([objects]).preload(:anything) # => we only initial loader but didn't perform it yet
-objects.map(&:anything) # => loading happen for the first time (without N+1)
+users = [User.new, User.new] # => nothing was done for loading
+N1Loader::Preloader.new([users]).preload(:orders_count) # => we only initialized loader but didn't perform it yet
+users.map(&:orders_count) # => loading has happen for the first time (without N+1)
 ```
 
 
 ### Shareable loaders
 
 ```ruby
-class MyLoader < N1Loader::Loader
-  def perform(elements)
-    elements.each { |element| fulfill(element, [element]) }
+class OrdersCountLoader < N1Loader::Loader
+  def perform(users)
+    orders_per_user = Order.where(user: users).group(:user_id).count
+
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
-class A
+class User
   include N1Loader::Loadable
   
-  n1_loader :anything, MyLoader
+  n1_loader :orders_count, OrdersCountLoader
 end
 
-class B
+class Customer
   include N1Loader::Loadable
   
-  n1_loader :something, MyLoader
+  n1_loader :orders_count, OrdersCountLoader
 end
 
-A.new.anything # => works
-B.new.something  # => works
+User.new.orders_count # => works
+Customer.new.orders_count  # => works
 ```
 
 ### Reloading
 
 ```ruby
-class Example
+class User
   include N1Loader::Loadable
 
   # with inline loader
-  n1_loader :anything do |elements|
-    elements.each { |element| fulfill(element, [element]) }
+  n1_loader :orders_count do |users|
+    orders_per_user = Order.where(user: users).group(:user_id).count
+
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
-object = Example.new
-object.anything # => loader is executed first time and value was cached
-object.anything(reload: true) # => loader is executed again and a new value was cached
+user = User.new
+user.orders_count # => loader is executed first time and value was cached
+user.orders_count(reload: true) # => loader is executed again and a new value was cached
 
-objects = [Example.new, Example.new]
+users = [User.new, User.new]
+N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized but not yet executed
+users.map(&:orders_count) # => loader was executed first time without N+1 issue and values were cached
 
-N1Loader::Preloader.new(objects).preload(:anything) # => loader was initialized but not yet executed
-objects.map(&:anything) # => loader was executed first time without N+1 issue and values were cached
-
-N1Loader::Preloader.new(objects).preload(:anything) # => loader was initialized again but not yet executed
-objects.map(&:anything) # => new loader was executed first time without N+1 issue and new values were cached
+N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized again but not yet executed
+users.map(&:orders_count) # => new loader was executed first time without N+1 issue and new values were cached
 ```
 
 ### Isolated loaders
 
 ```ruby
-class MyLoader < N1Loader::Loader
+class IsolatedLoader < N1Loader::Loader
   def perform(elements)
     elements.each { |element| fulfill(element, [element]) }
   end
 end
 
 objects = [1, 2, 3, 4]
-loader = MyLoader.new(objects)
+loader = IsolatedLoader.new(objects)
 objects.each do |object|
   loader.for(object) # => it has no N+1 and it doesn't require to be injected in the class
 end
@@ -160,46 +157,92 @@ end
 ### Optimized single case
 
 ```ruby
-class Example
+class User
   include N1Loader::Loadable
   
-  n1_loader :something do # no arguments passed to the block, so we can override both perform and single.
-    def perform(elements)
-      elements.each { |element| fulfill(element, [element]) }
+  n1_loader :orders_count do # no arguments passed to the block, so we can override both perform and single.
+    def perform(users)
+      orders_per_user = Order.where(user: users).group(:user_id).count
+
+      users.each { |user| fulfill(user, orders_per_user[user.id]) }
     end
     
     # Optimized for single object loading
-    def single(element)
-      # Just return a value you want to have for this element
-      [element]
+    def single(user)
+      user.orders.count
     end
   end
 end
 
-object = Example.new
-object.something # single will be used here
+user = User.new
+user.orders_count # single will be used here
 
-objects = [Example.new, Example.new]
-N1Loader::Preloader.new(objects).preload(:something)
-objects.map(&:something) # perform will be used once without N+1
+users = [User.new, User.new]
+N1Loader::Preloader.new(users).preload(:orders_count)
+users.map(&:orders_count) # perform will be used once without N+1
 ```
 
-## Integrations
+### Arguments
 
-### [ActiveRecord][5]
+```ruby
+class User
+  include N1Loader::Loadable
+
+  n1_loader :orders_count do |users, type|
+    orders_per_user = Order.where(type: type, user: users).group(:user_id).count
+
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
+  end
+end
+
+user = User.new
+user.orders_count(:gifts) # The loader will be performed first time for this argument
+user.orders_count(:sales) # The loader will be performed first time for this argument
+user.orders_count(:gifts) # The cached value will be used
+
+users = [User.new, User.new]
+N1Loader::Preloader.new(users).preload(:orders_count)
+users.map { |user| user.orders_count(:gifts) } # No N+1 here
+```
+
+_Note_: By default, we use `arguments.map(&:object_id)` to identify arguments but in some cases, 
+you may want to override it, for example:
+
+```ruby
+class User
+  include N1Loader::Loadable
+
+  n1_loader :orders_count do
+    def perform(users, sale)
+      orders_per_user = Order.where(sale: sale, user: users).group(:user_id).count
+      
+      users.each { |user| fulfill(user, orders_per_user[user.id]) }
+    end
+
+    def self.arguments_key(sale)
+      sale.id
+    end
+  end
+end
+
+user = User.new
+user.orders_count(Sale.first) # perform will be executed and value will be cached
+user.orders_count(Sale.first) # the cached value will be returned
+```
 
-**Supported versions**: 5, 6. 
 
-_Note_: Please open an issue if you interested in support of version 7 or other.
+## Integrations
+
+### [ActiveRecord][5]
 
 ```ruby
 class User < ActiveRecord::Base
   include N1Loader::Loadable
   
   n1_loader :orders_count do |users|
-    hash = Order.where(user: users).group(:user_id).count
-    
-    users.each { |user| fulfill(user, hash[user.id]) }
+    orders_per_user = Order.where(user: users).group(:user_id).count
+
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
@@ -225,9 +268,9 @@ class User < ActiveRecord::Base
   include N1Loader::Loadable
   
   n1_loader :orders_count do |users|
-    hash = Order.where(user: users).group(:user_id).count
+    orders_per_user = Order.where(user: users).group(:user_id).count
 
-    users.each { |user| fulfill(user, hash[user.id]) }
+    users.each { |user| fulfill(user, orders_per_user[user.id]) }
   end
 end
 
@@ -244,12 +287,6 @@ ArLazyPreload.config.auto_preload = true
 User.all.map(:orders_count)
 ```
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/djezzzl/n1_loader. 

data/{gemfiles → activerecord-gemfiles}/ar_5_latest.gemfile

@@ -1,7 +1,3 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
-
 gem "activerecord", "~> 5"
-
-gemspec path: "../"

data/{gemfiles → activerecord-gemfiles}/ar_6_latest.gemfile

@@ -1,7 +1,3 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
-
 gem "activerecord", "~> 6"
-
-gemspec path: "../"

data/ar_lazy_preload-gemfiles/ar_lazy_preload_0.6.1.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem "ar_lazy_preload", "= 0.6.1"

data/ar_lazy_preload-gemfiles/ar_lazy_preload_master.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem "ar_lazy_preload", git: "https://github.com/DmitryTsepelev/ar_lazy_preload", branch: "master"

data/lib/n1_loader/active_record/loader_collection.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+N1Loader::LoaderCollection.define_method :preloaded_records do
+  unless loader_class.instance_method(:perform).arity == 1
+    raise N1Loader::ActiveRecord::InvalidPreloading, "Cannot preload loader with arguments"
+  end
+
+  with.preloaded_records
+end

data/lib/n1_loader/active_record.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
+# Load core library
 require_relative "../n1_loader"
-require_relative "active_record/loader"
+
+# Load integration dependency
 require "active_record"
 
+module N1Loader
+  module ActiveRecord
+    class InvalidPreloading < N1Loader::Error; end
+  end
+end
+
+# Library integration
 ActiveSupport.on_load(:active_record) do
+  require_relative "active_record/loader"
+  require_relative "active_record/loader_collection"
+
   case ActiveRecord::VERSION::MAJOR
   when 6
     require_relative "active_record/associations_preloader_v6"

data/lib/n1_loader/ar_lazy_preload/associated_context_builder.rb

@@ -4,9 +4,16 @@ module N1Loader
   module ArLazyPreload
     # Context builder for N1Loader
     class AssociatedContextBuilder < ::ArLazyPreload::AssociatedContextBuilder
+      attr_reader :records
+
+      def initialize(parent_context:, association_name:, records:)
+        super(parent_context: parent_context, association_name: association_name)
+        @records = records
+      end
+
       def perform
         ::ArLazyPreload::Context.register(
-          records: parent_context.records.flat_map(&association_name),
+          records: records.flatten(1).select { |record| record.respond_to?(:lazy_preload_context=) },
           association_tree: child_association_tree,
           auto_preload: parent_context.auto_preload?
         )

data/lib/n1_loader/ar_lazy_preload/context_adapter.rb

@@ -19,12 +19,15 @@ module N1Loader
       end
 
       def perform_preloading(association_name)
-        N1Loader::Preloader.new(records).preload(association_name)
+        context_setup = lambda { |records|
+          AssociatedContextBuilder.prepare(
+            parent_context: self,
+            association_name: association_name,
+            records: records
+          )
+        }
 
-        AssociatedContextBuilder.prepare(
-          parent_context: self,
-          association_name: association_name
-        )
+        N1Loader::Preloader.new(records, context_setup).preload(association_name)
       end
     end
   end

data/lib/n1_loader/ar_lazy_preload/loadable.rb

@@ -9,13 +9,13 @@ module N1Loader
 
           define_method(loader_name) do
             loader = instance_variable_get(loader_variable_name)
-
             return loader if loader
+
             if respond_to?(:lazy_preload_context) && ContextAdapter.new(lazy_preload_context).try_preload_lazily(name)
               return instance_variable_get(loader_variable_name)
             end
 
-            instance_variable_set(loader_variable_name, self.class.send(loader_name).new([self]))
+            send("#{loader_name}_reload")
           end
         end
       end

data/lib/n1_loader/ar_lazy_preload/loader_collection_patch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ArLazyPreload
+    # A patch to {N1Loader::LoaderCollection} to setup lazy context lazily.
+    module LoaderCollectionPatch
+      attr_accessor :context_setup
+
+      def with(*args)
+        result = super
+
+        result.context_setup = context_setup if context_setup && result.context_setup.nil?
+
+        result
+      end
+    end
+  end
+end

data/lib/n1_loader/ar_lazy_preload/loader_patch.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ArLazyPreload
+    # A patch to {N1Loader::Loader} to setup lazy context lazily.
+    module LoaderPatch
+      attr_accessor :context_setup
+
+      def loaded
+        return @loaded if @loaded
+
+        super
+
+        context_setup&.call(preloaded_records)
+
+        @loaded
+      end
+    end
+  end
+end

data/lib/n1_loader/ar_lazy_preload/preloader_patch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ArLazyPreload
+    # A patch to {N1Loader::Preloader} setup lazy context lazily.
+    module PreloaderPatch
+      def initialize(elements, context_setup = nil)
+        super(elements)
+        @context_setup = context_setup
+      end
+
+      def preload(*keys)
+        super.each do |loader_collection|
+          loader_collection.context_setup = context_setup
+        end
+      end
+
+      private
+
+      attr_reader :context_setup
+    end
+  end
+end

data/lib/n1_loader/ar_lazy_preload.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
+# Load core library
 require_relative "active_record"
 
+# Load integration dependency
 require "rails"
 require "ar_lazy_preload"
 
+# Library integration
 require_relative "ar_lazy_preload/loadable"
 require_relative "ar_lazy_preload/context_adapter"
 require_relative "ar_lazy_preload/associated_context_builder"
+require_relative "ar_lazy_preload/loader_collection_patch"
+require_relative "ar_lazy_preload/preloader_patch"
+require_relative "ar_lazy_preload/loader_patch"
 
 N1Loader::Loadable::ClassMethods.prepend(N1Loader::ArLazyPreload::Loadable::ClassMethods)
+N1Loader::Preloader.prepend(N1Loader::ArLazyPreload::PreloaderPatch)
+N1Loader::Loader.prepend(N1Loader::ArLazyPreload::LoaderPatch)
+N1Loader::LoaderCollection.prepend(N1Loader::ArLazyPreload::LoaderCollectionPatch)

data/lib/n1_loader/core/loadable.rb

@@ -7,8 +7,10 @@ module N1Loader
   #     include N1Loader::Loadable
   #
   #     # with inline loader
-  #     n1_loader :something do |elements|
-  #       elements.each { |element| fulfill(element,, element.calculate_something) }
+  #     n1_loader :something do
+  #       def perform(elements)
+  #         elements.each { |element| fulfill(element,, element.calculate_something) }
+  #       end
   #     end
   #
   #     # with custom loader
@@ -26,8 +28,8 @@ module N1Loader
       send("#{name}_loader")
     end
 
-    def n1_loader_set(name, loader)
-      send("#{name}_loader=", loader)
+    def n1_loader_set(name, loader_collection)
+      send("#{name}_loader=", loader_collection)
     end
 
     def self.included(base)
@@ -45,13 +47,12 @@ module N1Loader
 
       def n1_load(name, loader = nil, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         loader ||= Class.new(N1Loader::Loader) do
-          if block && block.arity == 1
+          if block&.arity&.positive?
             define_method(:perform, &block)
           else
             class_eval(&block)
           end
         end
-
         loader_name = "#{name}_loader"
         loader_variable_name = "@#{loader_name}"
 
@@ -60,21 +61,22 @@ module N1Loader
         end
 
         define_method("#{loader_name}_reload") do
-          instance_variable_set(loader_variable_name, self.class.send(loader_name).new([self]))
+          instance_variable_set(loader_variable_name,
+                                N1Loader::LoaderCollection.new(self.class.send(loader_name), [self]))
         end
 
-        define_method("#{loader_name}=") do |loader_instance|
-          instance_variable_set(loader_variable_name, loader_instance)
+        define_method("#{loader_name}=") do |loader_collection_instance|
+          instance_variable_set(loader_variable_name, loader_collection_instance)
         end
 
         define_method(loader_name) do
           instance_variable_get(loader_variable_name) || send("#{loader_name}_reload")
         end
 
-        define_method(name) do |reload: false|
+        define_method(name) do |*args, reload: false|
           send("#{loader_name}_reload") if reload
 
-          send(loader_name).for(self)
+          send(loader_name).with(*args).for(self)
         end
 
         [name, loader_name, loader_variable_name]

data/lib/n1_loader/core/loader.rb

@@ -6,8 +6,13 @@ module N1Loader
   # Subclasses must define +perform+ method that accepts single argument
   # and returns hash where key is the element and value is what we want to load.
   class Loader
-    def initialize(elements)
+    def self.arguments_key(*args)
+      args.map(&:object_id)
+    end
+
+    def initialize(elements, *args)
       @elements = elements
+      @args = args
     end
 
     def for(element)
@@ -21,7 +26,7 @@ module N1Loader
 
     private
 
-    attr_reader :elements
+    attr_reader :elements, :args
 
     def perform(_elements)
       raise NotImplemented, "Subclasses have to implement the method"
@@ -37,9 +42,9 @@ module N1Loader
       @loaded = {}.compare_by_identity
 
       if elements.size == 1 && respond_to?(:single)
-        fulfill(elements.first, single(elements.first))
+        fulfill(elements.first, single(elements.first, *args))
       elsif elements.any?
-        perform(elements)
+        perform(elements, *args)
       end
 
       @loaded

data/lib/n1_loader/core/loader_collection.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module N1Loader
+  # The class is used for storing collections of loaders for elements per set of arguments.
+  class LoaderCollection
+    attr_reader :loader_class, :elements
+
+    def initialize(loader_class, elements)
+      @loader_class = loader_class
+      @elements = elements
+    end
+
+    def with(*args)
+      loaders[loader_class.arguments_key(*args)] ||= loader_class.new(elements, *args)
+    end
+
+    private
+
+    def loaders
+      @loaders ||= {}
+    end
+  end
+end

data/lib/n1_loader/core/preloader.rb

@@ -19,9 +19,9 @@ module N1Loader
         elements
           .group_by { |element| element.class.n1_loader(key) }
           .map do |loader_class, grouped_elements|
-            loader = loader_class.new(grouped_elements)
-            grouped_elements.each { |grouped_element| grouped_element.n1_loader_set(key, loader) }
-            loader
+            loader_collection = N1Loader::LoaderCollection.new(loader_class, grouped_elements)
+            grouped_elements.each { |grouped_element| grouped_element.n1_loader_set(key, loader_collection) }
+            loader_collection
           end
       end
     end

data/lib/n1_loader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module N1Loader
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/n1_loader.rb

@@ -3,6 +3,7 @@
 require_relative "n1_loader/version"
 
 require_relative "n1_loader/core/loader"
+require_relative "n1_loader/core/loader_collection"
 require_relative "n1_loader/core/loadable"
 require_relative "n1_loader/core/preloader"
 

data/n1_loader.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Evgeniy Demin"]
   spec.email         = ["lawliet.djez@gmail.com"]
 
-  spec.summary       = "N+1 loader to solve the problem for good."
+  spec.summary       = "Loader to solve N+1 issue for good."
   spec.homepage      = "https://github.com/djezzzl/n1_loader"
   spec.license       = "MIT"
   spec.required_ruby_version = ">= 2.5.0"
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "activerecord", ">= 5"
-  spec.add_development_dependency "ar_lazy_preload", "~> 0.7"
+  spec.add_development_dependency "ar_lazy_preload", ">= 0.6"
   spec.add_development_dependency "db-query-matchers", "~> 0.10"
   spec.add_development_dependency "rails", ">= 5"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n1_loader
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-27 00:00:00.000000000 Z
+date: 2022-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,16 +28,16 @@ dependencies:
   name: ar_lazy_preload
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: db-query-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -139,21 +139,28 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- activerecord-gemfiles/ar_5_latest.gemfile
+- activerecord-gemfiles/ar_6_latest.gemfile
+- ar_lazy_preload-gemfiles/ar_lazy_preload_0.6.1.gemfile
+- ar_lazy_preload-gemfiles/ar_lazy_preload_master.gemfile
 - bin/console
 - bin/setup
-- gemfiles/ar_5_latest.gemfile
-- gemfiles/ar_6_latest.gemfile
 - lib/n1_loader.rb
 - lib/n1_loader/active_record.rb
 - lib/n1_loader/active_record/associations_preloader_v5.rb
 - lib/n1_loader/active_record/associations_preloader_v6.rb
 - lib/n1_loader/active_record/loader.rb
+- lib/n1_loader/active_record/loader_collection.rb
 - lib/n1_loader/ar_lazy_preload.rb
 - lib/n1_loader/ar_lazy_preload/associated_context_builder.rb
 - lib/n1_loader/ar_lazy_preload/context_adapter.rb
 - lib/n1_loader/ar_lazy_preload/loadable.rb
+- lib/n1_loader/ar_lazy_preload/loader_collection_patch.rb
+- lib/n1_loader/ar_lazy_preload/loader_patch.rb
+- lib/n1_loader/ar_lazy_preload/preloader_patch.rb
 - lib/n1_loader/core/loadable.rb
 - lib/n1_loader/core/loader.rb
+- lib/n1_loader/core/loader_collection.rb
 - lib/n1_loader/core/preloader.rb
 - lib/n1_loader/version.rb
 - n1_loader.gemspec
@@ -182,5 +189,5 @@ requirements: []
 rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
-summary: N+1 loader to solve the problem for good.
+summary: Loader to solve N+1 issue for good.
 test_files: []