n1_loader 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be50b582e5f3bc33bb085b9ceefb620f3c1c49b28618e953103bf47ff343ffe6
-  data.tar.gz: bc9008a74662754eb20a798dd1969a59551f0127b6484561420335276980acf5
+  metadata.gz: e86d093c173eed577feb029f483c8b283f516bba1611391f9036e5675dec91d5
+  data.tar.gz: 626e0305af7e75fd6a5dbb23d6970a8972ca292a9449f2f32d61cf7849c57ec9
 SHA512:
-  metadata.gz: 0bef5f775c2ac8d31ad828d8b6ef55f7a9915eb19e8f0e2169a8196cf3ed71bd5153b4bbdb36e664b5994a9a0e47b196905772470accfafcd803438d83de43c7
-  data.tar.gz: d609dab38a23c3d0e87da754345477e5c1eaa00dcab59435b6015dfe010a1fd49f833139aa0610bc318fa467396a654b8134b3a1d2399267e85b090c22b9f995
+  metadata.gz: 3b450b20c25c935d3644003bf320e50644376cb6fc77cbda414522947a50857c3b28c5607bbcfd484dd9626a64523726cb4c6dd98b402a9ed3b73f1d6a40785a
+  data.tar.gz: 9d07c4a64e89f2c2e9aa230d86c780388aaf720002db5fac37fe9b98ffd6297b914ab49ec54306c728c3457ea7a323a52d66c3c9e78c40ccbaed0a511be1f012

data/.circleci/config.yml

@@ -86,8 +86,15 @@ workflows:
                 "latest"
               ]
               gemfile: [
+                "gemfiles/ar_5_latest.gemfile",
                 "gemfiles/ar_6_latest.gemfile"
               ]
+            exclude:
+              - ruby-version: "3.0"
+                gemfile: "gemfiles/ar_5_latest.gemfile"
+              - ruby-version: "latest"
+                gemfile: "gemfiles/ar_5_latest.gemfile"
+
           name: << matrix.gemfile >>-build-ruby-<< matrix.ruby-version >>
       - rubocop:
           requires:

data/CHANGELOG.md

@@ -1,5 +1,7 @@
-## [Unreleased]
+## [1.0.0] - 2021-12-26
+
+- Various of great features.
 
 ## [0.1.0] - 2021-12-16
 
-- Initial release
+- Initial release.

data/README.md

@@ -9,11 +9,15 @@ We have a solution for you!
 [N1Loader][8] is designed to solve the issue for good!
 
 It has many benefits:
-- it loads data lazily (even when you initialized preloading)
-- it supports shared loaders between multiple classes
+- it can be [isolated](#isolated-loaders)
+- it loads data [lazily](#lazy-loading)
+- it supports [shareable loaders](#shareable-loaders) between multiple classes
+- it supports [reloading](#reloading)
+- it supports optimized [single object loading](#optimized-single-case)
 - 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))
 
+... and even more features to come! Stay tuned!
 
 ## Installation
 
@@ -25,16 +29,18 @@ gem 'n1_loader'
 
 You can add integration with [ActiveRecord][5] by:
 ```ruby
-require 'n1_loader/active_record'
+gem 'n1_loader', require: 'n1_loader/active_record'
 ```
 
 You can add the integration with [ActiveRecord][5] and [ArLazyPreload][6] by:
 ```ruby
-require 'n1_loader/ar_lazy_preload'
+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
   include N1Loader::Loadable
@@ -67,8 +73,132 @@ N1Loader::Preloader.new(objects).preload(:anything)
 objects.map(&:anything)
 ```
 
+### Lazy loading
+
+```ruby
+class Example
+  include N1Loader::Loadable
+  
+  n1_loader :anything do |elements|
+    # Has to return a hash that has keys as element from elements
+    elements.group_by(&:itself)
+  end
+end
+
+object = Example.new # => nothing was done for loading
+object.anything # => 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)
+```
+
+
+### Shareable loaders
+
+```ruby
+class MyLoader < N1Loader::Loader
+  def perform(elements)
+    # Has to return a hash that has keys as element from elements
+    elements.group_by(&:itself)
+  end
+end
+
+class A
+  include N1Loader::Loadable
+  
+  n1_loader :anything, MyLoader
+end
+
+class B
+  include N1Loader::Loadable
+  
+  n1_loader :something, MyLoader
+end
+
+A.new.anything # => works
+B.new.something  # => works
+```
+
+### Reloading
+
+```ruby
+class Example
+  include N1Loader::Loadable
+
+  # with inline loader
+  n1_loader :anything do |elements|
+    # Has to return a hash that has keys as element from elements
+    elements.group_by(&:itself)
+  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
+
+objects = [Example.new, Example.new]
+
+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
+```
+
+### Isolated loaders
+
+```ruby
+class MyLoader < N1Loader::Loader
+  def perform(elements)
+    # Has to return a hash that has keys as element from elements
+    elements.group_by(&:itself)
+  end
+end
+
+objects = [1, 2, 3, 4]
+loader = MyLoader.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
+```
+
+### Optimized single case
+
+```ruby
+class Example
+  include N1Loader::Loadable
+  
+  n1_loader :something do # no arguments passed to the block, so we can override both perform and single.
+    def perform(elements)
+      # Has to return a hash that has keys as element from elements
+      elements.group_by(&:itself)
+    end
+    
+    # Optimized for single object loading
+    def single(element)
+      # Just return a value you want to have for this element
+      element
+    end
+  end
+end
+
+object = Example.new
+object.something # 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
+```
+
+## Integrations
+
 ### [ActiveRecord][5]
 
+**Supported versions**: 5, 6. 
+
+_Note_: Please open an issue if you interested in support of version 7 or other.
+
 ```ruby
 class User < ActiveRecord::Base
   include N1Loader::Loadable

data/gemfiles/ar_5_latest.gemfile

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

data/lib/n1_loader/active_record/associations_preloader_v5.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ActiveRecord
+    module Associations
+      module Preloader # :nodoc:
+        N1LoaderReflection = Struct.new(:key, :loader) do
+          def options
+            {}
+          end
+        end
+
+        def preloaders_for_one(association, records, scope)
+          grouped_records(association, records).flat_map do |reflection, klasses|
+            next N1Loader::Preloader.new(records).preload(reflection.key) if reflection.is_a?(N1LoaderReflection)
+
+            klasses.map do |rhs_klass, rs|
+              loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
+              loader.run self
+              loader
+            end
+          end
+        end
+
+        def grouped_records(association, records)
+          n1_load_records, records = records.partition do |record|
+            record.class.respond_to?(:n1_loader_defined?) && record.class.n1_loader_defined?(association)
+          end
+
+          hash = n1_load_records.group_by do |record|
+            N1LoaderReflection.new(association, record.class.n1_loader(association))
+          end
+
+          hash.merge(super)
+        end
+      end
+    end
+  end
+end

data/lib/n1_loader/active_record.rb

@@ -4,8 +4,13 @@ require_relative "../n1_loader"
 
 require "active_record"
 
-require_relative "active_record/associations_preloader"
-
 ActiveSupport.on_load(:active_record) do
+  case ActiveRecord::VERSION::MAJOR
+  when 6
+    require_relative "active_record/associations_preloader_v6"
+  else
+    require_relative "active_record/associations_preloader_v5"
+  end
+
   ActiveRecord::Associations::Preloader.prepend(N1Loader::ActiveRecord::Associations::Preloader)
 end

data/lib/n1_loader/ar_lazy_preload/context_adapter.rb

@@ -6,7 +6,7 @@ module N1Loader
     class ContextAdapter
       attr_reader :context
 
-      delegate :records, :auto_preload?, to: :context
+      delegate_missing_to :context
 
       def initialize(context)
         @context = context

data/lib/n1_loader/core/loadable.rb

@@ -47,9 +47,13 @@ module N1Loader
         respond_to?("#{name}_loader")
       end
 
-      def n1_load(name, loader = nil, &block) # rubocop:disable Metrics/MethodLength
+      def n1_load(name, loader = nil, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         loader ||= Class.new(N1Loader::Loader) do
-          define_method(:perform, &block)
+          if block && block.arity == 1
+            define_method(:perform, &block)
+          else
+            class_eval(&block)
+          end
         end
 
         loader_name = "#{name}_loader"
@@ -59,16 +63,21 @@ module N1Loader
           loader
         end
 
+        define_method("#{loader_name}_reload") do
+          instance_variable_set(loader_variable_name, self.class.send(loader_name).new([self]))
+        end
+
         define_method("#{loader_name}=") do |loader_instance|
           instance_variable_set(loader_variable_name, loader_instance)
         end
 
         define_method(loader_name) do
-          instance_variable_get(loader_variable_name) ||
-            instance_variable_set(loader_variable_name, self.class.send(loader_name).new([self]))
+          instance_variable_get(loader_variable_name) || send("#{loader_name}_reload")
         end
 
-        define_method(name) do
+        define_method(name) do |reload: false|
+          send("#{loader_name}_reload") if reload
+
           send(loader_name).for(self)
         end
 

data/lib/n1_loader/core/loader.rb

@@ -15,7 +15,11 @@ module N1Loader
     end
 
     def loaded
-      @loaded ||= perform(elements)
+      @loaded ||= if elements.size == 1 && respond_to?(:single)
+                    { elements.first => single(elements.first) }
+                  else
+                    perform(elements)
+                  end
     end
 
     def preloaded_records

data/lib/n1_loader/version.rb

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

data/n1_loader.gemspec

@@ -22,10 +22,10 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "activerecord", "~> 6.0"
+  spec.add_development_dependency "activerecord", ">= 5"
   spec.add_development_dependency "ar_lazy_preload", "~> 0.7"
   spec.add_development_dependency "db-query-matchers", "~> 0.10"
-  spec.add_development_dependency "rails", "~> 6.0"
+  spec.add_development_dependency "rails", ">= 5"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"
   spec.add_development_dependency "rubocop", "~> 1.7"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: n1_loader
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-21 00:00:00.000000000 Z
+date: 2021-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: ar_lazy_preload
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -141,10 +141,12 @@ files:
 - Rakefile
 - 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.rb
+- lib/n1_loader/active_record/associations_preloader_v5.rb
+- lib/n1_loader/active_record/associations_preloader_v6.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