n1_loader 1.7.0 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9be9c5e7d5e551d253a327cd3d130a38821ef49a43cab60235cc5363a4093d0
-  data.tar.gz: 55c8e748bf52fc05b8648d81d907963b4a60eae0b7aa680d0c491987b43303d3
+  metadata.gz: 61980f2b94429810da38a914db9e3779385a86cf0fbe95773311b19a2551c5a3
+  data.tar.gz: 8817ef5434d16ba5eb13deec0a78110fae07b9def1256e6b1d163deb02ed5a05
 SHA512:
-  metadata.gz: b626c836856198a9e0d0f54daedd0299b2cd7eb0648ddde369a6b7f923751b31d402c8ba03ab67bb064b884e5c5f035babcd1f59d0bef93db26968f7e6fca7ae
-  data.tar.gz: 640e8decd4c53e4f09451041392b964b5f0e59a273719673978e4bf62d26543364b5b4166d97833b7a5084ebacfe7921a921a5c0aae3938c3ce9394f6627bfc8
+  metadata.gz: b78afcfdc23c584456a3e5daef5c8f18f102bafffffbb06640275afdd9ee2e65368384d29d2dd77f0a5c991a4c281d808086bc1648da38a304eac743b3265fcd
+  data.tar.gz: 26795d6614b90f868a6aaec760180e0270a4726c5ce0e1f88fc04b97cfc751a8627a8d94efc27d2443d82cc145207759b595afe3383a4f8a38cacc8af75d4b3f

data/CHANGELOG.md

@@ -1,4 +1,12 @@
-## [1.6.7] - 2023/07/30
+## [1.7.2] - 2023/08/04
+
+- Refactor core that ended up with speed boost.
+
+## [1.7.1] - 2023/07/30
+
+- Fix interface discrepancy for `N1LoaderReflection`. Thanks [Denis Talakevich](https://github.com/senid231) for suggesting it!
+
+## [1.7.0] - 2023/07/30
 
 Extend the flexibility of loading data comparison. Thanks [Nazar Matus](https://github.com/FunkyloverOne) for suggesting it! 
 

data/lib/n1_loader/active_record/associations_preloader_v5.rb

@@ -4,7 +4,7 @@ module N1Loader
   module ActiveRecord
     module Associations
       module Preloader # :nodoc:
-        N1LoaderReflection = Struct.new(:key, :loader) do
+        N1LoaderReflection = Struct.new(:name, :loader) do
           def options
             {}
           end
@@ -12,7 +12,7 @@ module N1Loader
 
         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)
+            next N1Loader::Preloader.new(records).preload(reflection.name) if reflection.is_a?(N1LoaderReflection)
 
             klasses.map do |rhs_klass, rs|
               loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
@@ -24,11 +24,11 @@ module N1Loader
 
         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)
+            record.class.respond_to?(:n1_loaders) && record.class.n1_loaders.key?(association)
           end
 
           hash = n1_load_records.group_by do |record|
-            N1LoaderReflection.new(association, record.class.n1_loader(association))
+            N1LoaderReflection.new(association, record.class.n1_loaders[association])
           end
 
           hash.merge(super)

data/lib/n1_loader/active_record/associations_preloader_v6.rb

@@ -4,7 +4,7 @@ module N1Loader
   module ActiveRecord
     module Associations
       module Preloader # :nodoc:
-        N1LoaderReflection = Struct.new(:key, :loader) do
+        N1LoaderReflection = Struct.new(:name, :loader) do
           def options
             {}
           end
@@ -13,16 +13,16 @@ module N1Loader
         def preloaders_for_reflection(reflection, records, scope)
           return super unless reflection.is_a?(N1LoaderReflection)
 
-          N1Loader::Preloader.new(records).preload(reflection.key)
+          N1Loader::Preloader.new(records).preload(reflection.name)
         end
 
         def grouped_records(association, records, polymorphic_parent)
           n1_load_records, records = records.partition do |record|
-            record.class.respond_to?(:n1_loader_defined?) && record.class.n1_loader_defined?(association)
+            record.class.respond_to?(:n1_loaders) && record.class.n1_loaders[association]
           end
 
           hash = n1_load_records.group_by do |record|
-            N1LoaderReflection.new(association, record.class.n1_loader(association))
+            N1LoaderReflection.new(association, record.class.n1_loaders[association])
           end
 
           hash.merge(super)

data/lib/n1_loader/active_record/associations_preloader_v7.rb

@@ -4,7 +4,7 @@ module N1Loader
   module ActiveRecord
     module Associations
       module Preloader # :nodoc:
-        N1LoaderReflection = Struct.new(:key, :loader) do
+        N1LoaderReflection = Struct.new(:name, :loader) do
           def options
             {}
           end
@@ -13,16 +13,16 @@ module N1Loader
         def preloaders_for_reflection(reflection, records)
           return super unless reflection.is_a?(N1LoaderReflection)
 
-          N1Loader::Preloader.new(records).preload(reflection.key)
+          N1Loader::Preloader.new(records).preload(reflection.name)
         end
 
         def grouped_records # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
           n1_load_records, records = source_records.partition do |record|
-            record.class.respond_to?(:n1_loader_defined?) && record.class.n1_loader_defined?(association)
+            record.class.respond_to?(:n1_loaders) && record.class.n1_loaders[association]
           end
 
           h = n1_load_records.group_by do |record|
-            N1LoaderReflection.new(association, record.class.n1_loader(association))
+            N1LoaderReflection.new(association, record.class.n1_loaders[association])
           end
 
           polymorphic_parent = !root? && parent.polymorphic?

data/lib/n1_loader/ar_lazy_preload/loadable.rb

@@ -2,22 +2,13 @@
 
 module N1Loader
   module ArLazyPreload
-    module Loadable
-      module ClassMethods # :nodoc:
-        def n1_optimized(name, loader = nil, &block)
-          name, loader_name, loader_variable_name = super
+    module Loadable # :nodoc:
+      def n1_loader(name)
+        return n1_loaders[name] if n1_loaders[name]
 
-          define_method(loader_name) do
-            loader = instance_variable_get(loader_variable_name)
-            return loader if loader
+        ContextAdapter.new(lazy_preload_context).try_preload_lazily(name) if respond_to?(:lazy_preload_context)
 
-            if respond_to?(:lazy_preload_context) && ContextAdapter.new(lazy_preload_context).try_preload_lazily(name)
-              return instance_variable_get(loader_variable_name)
-            end
-
-            send("#{loader_name}_reload")
-          end
-        end
+        super
       end
     end
   end

data/lib/n1_loader/ar_lazy_preload.rb

@@ -17,7 +17,7 @@ require_relative "ar_lazy_preload/loader_patch"
 require_relative "ar_lazy_preload/loader"
 require_relative "ar_lazy_preload/context"
 
-N1Loader::Loadable::ClassMethods.prepend(N1Loader::ArLazyPreload::Loadable::ClassMethods)
+N1Loader::Loadable.prepend(N1Loader::ArLazyPreload::Loadable)
 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,14 +7,14 @@ module N1Loader
   #     include N1Loader::Loadable
   #
   #     # with inline loader
-  #     n1_loader :something do
+  #     n1_optimized :something do
   #       def perform(elements)
   #         elements.each { |element| fulfill(element, element.calculate_something) }
   #       end
   #     end
   #
   #     # with custom loader
-  #     n1_loader :something, MyLoader
+  #     n1_optimized :something, MyLoader
   #   end
   #
   #   # custom loader
@@ -24,23 +24,21 @@ module N1Loader
   #     end
   #   end
   module Loadable
-    include Name
+    def n1_loaders
+      @n1_loaders ||= {}
+    end
 
     def n1_loader(name)
-      name = n1_loader_name(name)
-
-      send("#{name}_loader")
+      n1_loaders[name]
     end
 
-    def n1_loader_set(name, loader_collection)
-      name = n1_loader_name(name)
-
-      send("#{name}_loader=", loader_collection)
+    def n1_loader_reload(name)
+      n1_loaders[name] = LoaderCollection.new(self.class.n1_loaders[name], [self])
     end
 
     def n1_clear_cache
-      self.class.n1_loaders.each do |name|
-        n1_loader_set(name, nil)
+      self.class.n1_loaders.each_key do |name|
+        n1_loaders[name] = nil
       end
     end
 
@@ -49,61 +47,20 @@ module N1Loader
     end
 
     module ClassMethods # :nodoc:
-      include Name
-
-      def n1_loader(name)
-        name = n1_loader_name(name)
-
-        send("#{name}_loader")
-      end
-
-      def n1_loader_defined?(name)
-        name = n1_loader_name(name)
-
-        respond_to?("#{name}_loader")
-      end
-
       def n1_loaders
-        @n1_loaders ||= superclass.respond_to?(:n1_loaders) ? superclass.n1_loaders.dup : []
+        @n1_loaders ||= superclass.respond_to?(:n1_loaders) ? superclass.n1_loaders.dup : {}
       end
 
-      def n1_optimized(name, loader = nil, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        loader ||= Class.new(N1Loader::Loader) do
-          if block.arity == 1
-            define_method(:perform, &block)
-          else
-            class_eval(&block)
-          end
-        end
-        loader_name = "#{n1_loader_name(name)}_loader"
-        loader_variable_name = "@#{loader_name}"
-
-        n1_loaders << name
-
-        define_singleton_method(loader_name) do
-          loader
-        end
-
-        define_method("#{loader_name}_reload") do
-          instance_variable_set(loader_variable_name,
-                                N1Loader::LoaderCollection.new(self.class.send(loader_name), [self]))
-        end
+      def n1_optimized(name, loader = nil, &block)
+        loader ||= LoaderBuilder.build(&block)
 
-        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
+        n1_loaders[name] = loader
 
         define_method(name) do |reload: false, **args|
-          send("#{loader_name}_reload") if reload
+          n1_loader_reload(name) if reload || n1_loader(name).nil?
 
-          send(loader_name).with(**args).for(self)
+          n1_loader(name).with(**args).for(self)
         end
-
-        [name, loader_name, loader_variable_name]
       end
     end
   end

data/lib/n1_loader/core/loader.rb

@@ -62,11 +62,10 @@ module N1Loader
 
     attr_reader :elements, :args
 
-    def check_missing_arguments! # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def check_missing_arguments!
       return unless (arguments = self.class.arguments)
 
-      required_arguments = arguments.reject { |argument| argument[:optional] }
-                                    .map { |argument| argument[:name] }
+      required_arguments = required_arguments(arguments)
 
       return if required_arguments.all? { |argument| args.key?(argument) }
 
@@ -74,8 +73,12 @@ module N1Loader
 
       list = missing_arguments.map { |argument| ":#{argument}" }.join(", ")
 
-      raise MissingArgument,
-            "Loader requires [#{list}] arguments but they are missing"
+      raise MissingArgument, "Loader requires [#{list}] arguments but they are missing"
+    end
+
+    def required_arguments(args)
+      args.reject { |argument| argument[:optional] }
+          .map { |argument| argument[:name] }
     end
 
     def check_arguments!

data/lib/n1_loader/core/loader_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module N1Loader
+  # The class builds {N1Loader::Loader}
+  class LoaderBuilder
+    def self.build(&block)
+      Class.new(N1Loader::Loader) do
+        if block.arity == 1
+          define_method(:perform, &block)
+        else
+          class_eval(&block)
+        end
+      end
+    end
+  end
+end

data/lib/n1_loader/core/preloader.rb

@@ -18,22 +18,19 @@ module N1Loader
       keys.flatten(1).flat_map do |key|
         elements
           .group_by { |element| loader_class(element, key) }
-          .map do |loader_class, grouped_elements|
-            next unless loader_class
-
+          .select { |loader_class, _| loader_class }
+          .map do |(loader_class, grouped_elements)|
             loader_collection = N1Loader::LoaderCollection.new(loader_class, grouped_elements)
-            grouped_elements.each { |grouped_element| grouped_element.n1_loader_set(key, loader_collection) }
+            grouped_elements.each { |grouped_element| grouped_element.n1_loaders[key] = loader_collection }
             loader_collection
-          end.compact
+          end
       end
     end
 
     private
 
     def loader_class(element, key)
-      element.class.respond_to?(:n1_loader_defined?) &&
-        element.class.n1_loader_defined?(key) &&
-        element.class.n1_loader(key)
+      element.class.respond_to?(:n1_loaders) && element.class.n1_loaders[key]
     end
   end
 end

data/lib/n1_loader/version.rb

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

data/lib/n1_loader.rb

@@ -2,7 +2,7 @@
 
 require_relative "n1_loader/version"
 
-require_relative "n1_loader/core/name"
+require_relative "n1_loader/core/loader_builder"
 require_relative "n1_loader/core/loader"
 require_relative "n1_loader/core/loader_collection"
 require_relative "n1_loader/core/loadable"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n1_loader
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.2
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-30 00:00:00.000000000 Z
+date: 2023-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -195,8 +195,8 @@ files:
 - 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_builder.rb
 - lib/n1_loader/core/loader_collection.rb
-- lib/n1_loader/core/name.rb
 - lib/n1_loader/core/preloader.rb
 - lib/n1_loader/version.rb
 - n1_loader.gemspec

data/lib/n1_loader/core/name.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module N1Loader
-  # Add support of question mark names
-  module Name
-    def n1_loader_name(name)
-      to_sym = name.is_a?(Symbol)
-
-      converted = name.to_s.gsub("?", "_question_mark")
-
-      to_sym ? converted.to_sym : converted
-    end
-  end
-end