serega 0.11.1 → 0.12.0

data/lib/serega/plugins/preloads/lib/preloads_constructor.rb

@@ -35,8 +35,9 @@ class Serega
               append_current(preloads, current_preloads)
               next unless child_plan
 
-              child_preloads = dig?(preloads, point.preloads_path)
-              append_many(child_preloads, child_plan)
+              each_child_preloads(preloads, point.preloads_path) do |child_preloads|
+                append_many(child_preloads, child_plan)
+              end
             end
           end
 
@@ -50,14 +51,26 @@ class Serega
             end
           end
 
-          def dig?(hash, path)
-            return hash if !path || path.empty?
+          def each_child_preloads(preloads, preloads_path)
+            return yield(preloads) if preloads_path.nil?
 
-            path.each do |point|
-              hash = hash[point]
+            if preloads_path[0].is_a?(Array)
+              preloads_path.each do |path|
+                yield dig_fetch(preloads, path)
+              end
+            else
+              yield dig_fetch(preloads, preloads_path)
             end
+          end
+
+          def dig_fetch(preloads, preloads_path)
+            return preloads if !preloads_path || preloads_path.empty?
 
-            hash
+            preloads_path.each do |path|
+              preloads = preloads.fetch(path)
+            end
+
+            preloads
           end
         end
       end

data/lib/serega/plugins/preloads/preloads.rb

@@ -79,6 +79,18 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
+        require_relative "./lib/format_user_preloads"
+        require_relative "./lib/modules/attribute"
+        require_relative "./lib/modules/attribute_normalizer"
+        require_relative "./lib/modules/check_attribute_params"
+        require_relative "./lib/modules/config"
+        require_relative "./lib/modules/plan_point"
+        require_relative "./lib/preload_paths"
+        require_relative "./lib/preloads_config"
+        require_relative "./lib/preloads_constructor"
+        require_relative "./validations/check_opt_preload"
+        require_relative "./validations/check_opt_preload_path"
+
         serializer_class.include(InstanceMethods)
         serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
         serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
@@ -86,12 +98,6 @@ class Serega
         serializer_class::SeregaPlanPoint.include(PlanPointInstanceMethods)
 
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-
-        require_relative "./lib/format_user_preloads"
-        require_relative "./lib/main_preload_path"
-        require_relative "./lib/preloads_constructor"
-        require_relative "./validations/check_opt_preload"
-        require_relative "./validations/check_opt_preload_path"
       end
 
       #
@@ -125,210 +131,6 @@ class Serega
           @preloads ||= PreloadsConstructor.call(plan)
         end
       end
-
-      #
-      # Config for `preloads` plugin
-      #
-      class PreloadsConfig
-        # @return [Hash] preloads plugin options
-        attr_reader :opts
-
-        #
-        # Initializes context_metadata config object
-        #
-        # @param opts [Hash] options
-        #
-        # @return [Serega::SeregaPlugins::Metadata::MetadataConfig]
-        #
-        def initialize(opts)
-          @opts = opts
-        end
-
-        # @!method auto_preload_attributes_with_delegate
-        #   @return [Boolean, nil] option value
-        #
-        # @!method auto_preload_attributes_with_delegate=(value)
-        #   @param value [Boolean] New option value
-        #   @return [Boolean] New option value
-        #
-        # @!method auto_preload_attributes_with_serializer
-        #   @return [Boolean, nil] option value
-        #
-        # @!method auto_preload_attributes_with_serializer=(value)
-        #   @param value [Boolean] New option value
-        #   @return [Boolean] New option value
-        #
-        # @!method auto_hide_attributes_with_preload
-        #   @return [Boolean, nil] option value
-        #
-        # @!method auto_hide_attributes_with_preload=(value)
-        #   @param value [Boolean] New option value
-        #   @return [Boolean] New option value
-        #
-        %i[
-          auto_preload_attributes_with_delegate
-          auto_preload_attributes_with_serializer
-          auto_hide_attributes_with_preload
-        ].each do |method_name|
-          define_method(method_name) do
-            opts.fetch(method_name)
-          end
-
-          define_method("#{method_name}=") do |value|
-            raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
-            opts[method_name] = value
-          end
-        end
-      end
-
-      #
-      # Config class additional/patched instance methods
-      #
-      # @see Serega::SeregaConfig
-      #
-      module ConfigInstanceMethods
-        # @return [Serega::SeregaPlugins::Preloads::PreloadsConfig] `preloads` plugin config
-        def preloads
-          @preloads ||= PreloadsConfig.new(opts.fetch(:preloads))
-        end
-      end
-
-      #
-      # Serega::SeregaAttribute additional/patched instance methods
-      #
-      # @see Serega::SeregaAttribute::AttributeInstanceMethods
-      #
-      module AttributeInstanceMethods
-        # @return [Hash, nil] normalized preloads of current attribute
-        attr_reader :preloads
-
-        # @return [Array] normalized preloads_path of current attribute
-        attr_reader :preloads_path
-
-        private
-
-        def set_normalized_vars(normalizer)
-          super
-          @preloads = normalizer.preloads
-          @preloads_path = normalizer.preloads_path
-        end
-      end
-
-      #
-      # SeregaAttributeNormalizer additional/patched instance methods
-      #
-      # @see SeregaAttributeNormalizer::AttributeInstanceMethods
-      #
-      module AttributeNormalizerInstanceMethods
-        # @return [Hash,nil] normalized attribute preloads
-        def preloads
-          return @preloads if instance_variable_defined?(:@preloads)
-
-          @preloads = prepare_preloads
-        end
-
-        # @return [Array, nil] normalized attribute preloads path
-        def preloads_path
-          return @preloads_path if instance_variable_defined?(:@preloads_path)
-
-          @preloads_path = prepare_preloads_path
-        end
-
-        private
-
-        #
-        # Patched in:
-        # - plugin :batch (extension :preloads - skips auto preloads when batch option provided)
-        #
-        def prepare_preloads
-          opts = init_opts
-          preloads_provided = opts.key?(:preload)
-          preloads =
-            if preloads_provided
-              opts[:preload]
-            elsif opts.key?(:serializer) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_serializer
-              key
-            elsif opts.key?(:delegate) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_delegate
-              opts[:delegate].fetch(:to)
-            end
-
-          # Nil and empty hash differs as we can preload nested results to
-          # empty hash, but we will skip nested preloading if nil or false provided
-          return if preloads_provided && !preloads
-
-          FormatUserPreloads.call(preloads)
-        end
-
-        def prepare_preloads_path
-          opts = init_opts
-          path = Array(opts[:preload_path]).map!(&:to_sym).freeze
-          path = MainPreloadPath.call(preloads) if path.empty?
-          path
-        end
-
-        #
-        # Patch for original `prepare_hide` method
-        #
-        # Marks attribute hidden if auto_hide_attribute_with_preloads option was set and attribute has preloads
-        #
-        def prepare_hide
-          res = super
-          return res unless res.nil?
-
-          if preloads && !preloads.empty?
-            self.class.serializer_class.config.preloads.auto_hide_attributes_with_preload || nil
-          end
-        end
-      end
-
-      #
-      # Serega::SeregaPlanPoint additional/patched instance methods
-      #
-      # @see Serega::SeregaPlanPoint::InstanceMethods
-      #
-      module PlanPointInstanceMethods
-        #
-        # @return [Hash] preloads for nested attributes
-        #
-        attr_reader :preloads
-
-        #
-        # @return [Array<Symbol>] preloads path for current attribute
-        #
-        attr_reader :preloads_path
-
-        private
-
-        def set_normalized_vars
-          super
-
-          @preloads = prepare_preloads
-          @preloads_path = prepare_preloads_path
-        end
-
-        def prepare_preloads
-          PreloadsConstructor.call(child_plan)
-        end
-
-        def prepare_preloads_path
-          attribute.preloads_path
-        end
-      end
-
-      #
-      # Serega::SeregaValidations::CheckAttributeParams additional/patched class methods
-      #
-      # @see Serega::SeregaValidations::CheckAttributeParams
-      #
-      module CheckAttributeParamsInstanceMethods
-        private
-
-        def check_opts
-          super
-          CheckOptPreload.call(opts)
-          CheckOptPreloadPath.call(opts)
-        end
-      end
     end
 
     register_plugin(Preloads.plugin_name, Preloads)

data/lib/serega/plugins/preloads/validations/check_opt_preload_path.rb

@@ -18,30 +18,69 @@ class Serega
           # @return [void]
           #
           def call(opts)
-            return unless opts.key?(:preload_path)
+            return if exactly_nil?(opts, :preload_path) # allow to provide nil anyway
 
-            value = opts[:preload_path]
-            raise SeregaError, "Invalid option :preload_path => #{value.inspect}. Can be provided only when :preload option provided" unless opts[:preload]
-            raise SeregaError, "Invalid option :preload_path => #{value.inspect}. Can be provided only when :serializer option provided" unless opts[:serializer]
+            path = opts[:preload_path]
+            check_usage_with_other_options(path, opts)
+            return unless opts[:serializer]
 
-            path = Array(value).map!(&:to_sym)
-            preloads = FormatUserPreloads.call(opts[:preload])
-            allowed_paths = paths(preloads)
-            raise SeregaError, "Invalid option :preload_path => #{value.inspect}. Can be one of #{allowed_paths.inspect[1..-2]}" unless allowed_paths.include?(path)
+            check_allowed(path, opts)
           end
 
           private
 
-          def paths(preloads, path = [], result = [])
-            preloads.each do |key, nested_preloads|
-              path << key
-              result << path.dup
+          def exactly_nil?(opts, opt_name)
+            opts.fetch(opt_name, false).nil?
+          end
+
+          def check_allowed(path, opts)
+            allowed_paths = PreloadPaths.call(opts[:preload])
+            check_required_when_many_allowed(path, allowed_paths)
+            check_in_allowed(path, allowed_paths)
+          end
+
+          def check_usage_with_other_options(path, opts)
+            return unless path
+
+            preload = opts[:preload]
+            raise SeregaError, "Invalid option preload_path: #{path.inspect}. Can be provided only when :preload option provided" unless preload
 
-              paths(nested_preloads, path, result)
-              path.pop
+            serializer = opts[:serializer]
+            raise SeregaError, "Invalid option preload_path: #{path.inspect}. Can be provided only when :serializer option provided" unless serializer
+          end
+
+          def check_required_when_many_allowed(path, allowed)
+            return if path || (allowed.size < 2)
+
+            raise SeregaError, "Option :preload_path must be provided. Possible values: #{allowed.inspect[1..-2]}"
+          end
+
+          def check_in_allowed(path, allowed)
+            return if !path && allowed.size <= 1
+
+            if multiple_preload_paths_provided?(path)
+              check_many(path, allowed)
+            else
+              check_one(path, allowed)
             end
+          end
+
+          def check_one(path, allowed)
+            formatted_path = Array(path).map(&:to_sym)
+            return if allowed.include?(formatted_path)
+
+            raise SeregaError,
+              "Invalid preload_path (#{path.inspect}). " \
+              "Can be one of #{allowed.inspect[1..-2]}"
+          end
+
+          def check_many(paths, allowed)
+            paths.each { |path| check_one(path, allowed) }
+          end
 
-            result
+          # Check value is Array in Array
+          def multiple_preload_paths_provided?(value)
+            value.is_a?(Array) && value[0].is_a?(Array)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-25 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -43,8 +43,15 @@ files:
 - lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb
 - lib/serega/plugins/activerecord_preloads/lib/preloader.rb
 - lib/serega/plugins/batch/batch.rb
+- lib/serega/plugins/batch/lib/batch_config.rb
 - lib/serega/plugins/batch/lib/loader.rb
 - lib/serega/plugins/batch/lib/loaders.rb
+- lib/serega/plugins/batch/lib/modules/attribute.rb
+- lib/serega/plugins/batch/lib/modules/attribute_normalizer.rb
+- lib/serega/plugins/batch/lib/modules/check_attribute_params.rb
+- lib/serega/plugins/batch/lib/modules/config.rb
+- lib/serega/plugins/batch/lib/modules/object_serializer.rb
+- lib/serega/plugins/batch/lib/modules/plan_point.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/activerecord_preloads.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/formatters.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/preloads.rb
@@ -66,7 +73,13 @@ files:
 - lib/serega/plugins/metadata/validations/check_opts.rb
 - lib/serega/plugins/metadata/validations/check_path.rb
 - lib/serega/plugins/preloads/lib/format_user_preloads.rb
-- lib/serega/plugins/preloads/lib/main_preload_path.rb
+- lib/serega/plugins/preloads/lib/modules/attribute.rb
+- lib/serega/plugins/preloads/lib/modules/attribute_normalizer.rb
+- lib/serega/plugins/preloads/lib/modules/check_attribute_params.rb
+- lib/serega/plugins/preloads/lib/modules/config.rb
+- lib/serega/plugins/preloads/lib/modules/plan_point.rb
+- lib/serega/plugins/preloads/lib/preload_paths.rb
+- lib/serega/plugins/preloads/lib/preloads_config.rb
 - lib/serega/plugins/preloads/lib/preloads_constructor.rb
 - lib/serega/plugins/preloads/preloads.rb
 - lib/serega/plugins/preloads/validations/check_opt_preload.rb

data/lib/serega/plugins/preloads/lib/main_preload_path.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Class that constructs main preloads path.
-      #
-      # When we have nested preloads we will use this path to dig to `main` element and
-      # assign nested preloads to it.
-      #
-      # By default its a path to latest provided preload
-      #
-      # @example
-      #  MainPreloadPath.(a: { b: { c: {} }, d: {} }) # => [:a, :d]
-      #
-      class MainPreloadPath
-        class << self
-          # Finds default preload path
-          #
-          # @param preloads [Hash] Formatted user provided preloads hash
-          #
-          # @return [Array<Symbol>] Preloads path to `main` element
-          def call(preloads)
-            return FROZEN_EMPTY_ARRAY if !preloads || preloads.empty?
-
-            main_path(preloads).freeze
-          end
-
-          private
-
-          # Generates path (Array) to the last included resource.
-          # We need to know this path to include nested associations.
-          #
-          #  main_path(a: { b: { c: {} }, d: {} }) # => [:a, :d]
-          #
-          def main_path(hash, path = [])
-            current_level = path.size
-
-            hash.each do |key, data|
-              path.pop(path.size - current_level)
-              path << key
-
-              main_path(data, path)
-            end
-
-            path
-          end
-        end
-      end
-    end
-  end
-end