serega 0.21.0 → 0.31.0

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Serega::SeregaAttributeNormalizer additional/patched instance methods
-      #
-      # @see SeregaAttributeNormalizer::AttributeNormalizerInstanceMethods
-      #
-      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
-              method_name
-            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
-          path = init_opts.fetch(:preload_path) { default_preload_path(preloads) }
-
-          if path && path[0].is_a?(Array)
-            prepare_many_preload_paths(path)
-          else
-            prepare_one_preload_path(path)
-          end
-        end
-
-        def prepare_one_preload_path(path)
-          return unless path
-
-          case path
-          when Array
-            path.map(&:to_sym).freeze
-          else
-            [path.to_sym].freeze
-          end
-        end
-
-        def prepare_many_preload_paths(paths)
-          paths.map { |path| prepare_one_preload_path(path) }.freeze
-        end
-
-        def default_preload_path(preloads)
-          return FROZEN_EMPTY_ARRAY if !preloads || preloads.empty?
-
-          [preloads.keys.first]
-        end
-
-        #
-        # Patch for original `prepare_hide` method
-        # @see
-        #
-        # 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
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # 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
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # 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
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # 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
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Utility that helps to transform preloads to array of paths
-      #
-      # Example:
-      #
-      #   call({ a: { b: { c: {}, d: {} } }, e: {} })
-      #
-      #   => [
-      #        [:a],
-      #        [:a, :b],
-      #        [:a, :b, :c],
-      #        [:a, :b, :d],
-      #        [:e]
-      #      ]
-      class PreloadPaths
-        class << self
-          #
-          # Transforms user provided preloads to array of paths
-          #
-          # @param preloads [Array,Hash,String,Symbol,nil,false] association(s) to preload
-          #
-          # @return [Hash] preloads transformed to hash
-          #
-          def call(preloads)
-            formatted_preloads = FormatUserPreloads.call(preloads)
-            return FROZEN_EMPTY_ARRAY if formatted_preloads.empty?
-
-            paths(formatted_preloads, [], [])
-          end
-
-          private
-
-          def paths(formatted_preloads, path, result)
-            formatted_preloads.each do |key, nested_preloads|
-              path << key
-              result << path.dup
-
-              paths(nested_preloads, path, result)
-              path.pop
-            end
-
-            result
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Config for `preloads` plugin
-      #
-      class PreloadsConfig
-        # @return [Hash] preloads plugin options
-        attr_reader :opts
-
-        #
-        # Initializes PreloadsConfig object
-        #
-        # @param opts [Hash] options
-        #
-        # @return [Serega::SeregaPlugins::Preloads::PreloadsConfig]
-        #
-        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
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Finds preloads for provided attributes plan
-      #
-      class PreloadsConstructor
-        class << self
-          #
-          # Constructs preloads hash for given attributes plan
-          #
-          # @param plan [Array<SeregaPlanPoint>] Serialization plan
-          #
-          # @return [Hash]
-          #
-          def call(plan)
-            return FROZEN_EMPTY_HASH unless plan
-
-            preloads = {}
-            append_many(preloads, plan)
-            preloads
-          end
-
-          private
-
-          def append_many(preloads, plan)
-            plan.points.each do |point|
-              current_preloads = point.attribute.preloads
-              next unless current_preloads
-
-              child_plan = point.child_plan
-              current_preloads = SeregaUtils::EnumDeepDup.call(current_preloads) if child_plan
-              append_current(preloads, current_preloads)
-              next unless child_plan
-
-              each_child_preloads(preloads, point.preloads_path) do |child_preloads|
-                append_many(child_preloads, child_plan)
-              end
-            end
-          end
-
-          def append_current(preloads, current_preloads)
-            merge(preloads, current_preloads) unless current_preloads.empty?
-          end
-
-          def merge(preloads, current_preloads)
-            preloads.merge!(current_preloads) do |_key, value_one, value_two|
-              merge(value_one, value_two)
-            end
-          end
-
-          def each_child_preloads(preloads, preloads_path)
-            return yield(preloads) if preloads_path.nil?
-
-            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?
-
-            preloads_path.each do |path|
-              preloads = preloads.fetch(path)
-            end
-
-            preloads
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin `:preloads`
-    #
-    # Allows to define `:preloads` to attributes and then allows to merge preloads
-    # from serialized attributes and return single associations hash.
-    #
-    # Plugin accepts options:
-    # - `auto_preload_attributes_with_delegate` - default false
-    # - `auto_preload_attributes_with_serializer` - default false
-    # - `auto_hide_attributes_with_preload` - default false
-    #
-    # This options are very handy if you want to forget about finding preloads manually.
-    #
-    # Preloads can be disabled with `preload: false` attribute option.
-    # Also automatically added preloads can be overwritten with manually specified `preload: :another_value`.
-    #
-    # Some examples, **please read comments in the code below**
-    #
-    # @example
-    #   class AppSerializer < Serega
-    #     plugin :preloads,
-    #       auto_preload_attributes_with_delegate: true,
-    #       auto_preload_attributes_with_serializer: true,
-    #       auto_hide_attributes_with_preload: true
-    #   end
-    #
-    #   class UserSerializer < AppSerializer
-    #     # No preloads
-    #     attribute :username
-    #
-    #     # Specify `preload: :user_stats` manually
-    #     attribute :followers_count, preload: :user_stats, value: proc { |user| user.user_stats.followers_count }
-    #
-    #     # Automatically `preloads: :user_stats` as `auto_preload_attributes_with_delegate` option is true
-    #     attribute :comments_count, delegate: { to: :user_stats }
-    #
-    #     # Automatically `preloads: :albums` as `auto_preload_attributes_with_serializer` option is true
-    #     attribute :albums, serializer: 'AlbumSerializer'
-    #   end
-    #
-    #   class AlbumSerializer < AppSerializer
-    #     attribute :images_count, delegate: { to: :album_stats }
-    #   end
-    #
-    #   # By default preloads are empty, as we specify `auto_hide_attributes_with_preload = true`,
-    #   # and attributes with preloads will be not serialized
-    #   UserSerializer.new.preloads # => {}
-    #   UserSerializer.new.to_h(OpenStruct.new(username: 'foo')) # => {:username=>"foo"}
-    #
-    #   UserSerializer.new(with: :followers_count).preloads # => {:user_stats=>{}}
-    #   UserSerializer.new(with: %i[followers_count comments_count]).preloads # => {:user_stats=>{}}
-    #   UserSerializer.new(with: [:followers_count, :comments_count, { albums: :images_count }]).preloads # => {:user_stats=>{}, :albums=>{:album_stats=>{}}}
-    #
-
-    module Preloads
-      DEFAULT_CONFIG = {
-        auto_preload_attributes_with_delegate: false,
-        auto_preload_attributes_with_serializer: false,
-        auto_hide_attributes_with_preload: false
-      }.freeze
-
-      private_constant :DEFAULT_CONFIG
-
-      # @return [Symbol] Plugin name
-      def self.plugin_name
-        :preloads
-      end
-
-      # Checks requirements to load plugin
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] plugin options
-      #
-      # @return [void]
-      #
-      def self.before_load_plugin(serializer_class, **opts)
-        allowed_keys = DEFAULT_CONFIG.keys
-        opts.each_key do |key|
-          next if allowed_keys.include?(key)
-
-          raise SeregaError,
-            "Plugin #{plugin_name.inspect} does not accept the #{key.inspect} option. Allowed options:\n" \
-            "  - :auto_preload_attributes_with_delegate [Boolean] - Automatically adds `preload: <delegate_to>` option to attributes with :delegate option specified\n" \
-            "  - :auto_preload_attributes_with_serializer [Boolean] - Automatically adds `preload: <attribute_name>` option to attributes with :serializer option specified\n" \
-            "  - :auto_hide_attributes_with_preload [Boolean] - Automatically adds `hide: true` option to attributes with :preload option (specified manually or added automatically)"
-        end
-
-        if serializer_class.plugin_used?(:batch)
-          raise SeregaError, "Plugin #{plugin_name.inspect} must be loaded before the :batch plugin"
-        end
-      end
-
-      #
-      # Applies plugin code to specific serializer
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param _opts [Hash] Plugin options
-      #
-      # @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)
-        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
-        serializer_class::SeregaPlanPoint.include(PlanPointInstanceMethods)
-
-        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-      end
-
-      #
-      # Adds config options and runs other callbacks after plugin was loaded
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] Plugin options
-      #
-      # @return [void]
-      #
-      def self.after_load_plugin(serializer_class, **opts)
-        config = serializer_class.config
-        config.attribute_keys << :preload << :preload_path
-
-        preloads_opts = DEFAULT_CONFIG.merge(opts.slice(*DEFAULT_CONFIG.keys))
-        config.opts[:preloads] = {}
-        preloads_config = config.preloads
-        preloads_config.auto_preload_attributes_with_delegate = preloads_opts[:auto_preload_attributes_with_delegate]
-        preloads_config.auto_preload_attributes_with_serializer = preloads_opts[:auto_preload_attributes_with_serializer]
-        preloads_config.auto_hide_attributes_with_preload = preloads_opts[:auto_hide_attributes_with_preload]
-      end
-
-      #
-      # Serega additional/patched instance methods
-      #
-      # @see Serega
-      #
-      module InstanceMethods
-        # @return [Hash] merged preloads of all serialized attributes
-        def preloads
-          @preloads ||= PreloadsConstructor.call(plan)
-        end
-      end
-    end
-
-    register_plugin(Preloads.plugin_name, Preloads)
-  end
-end

data/lib/serega/utils/params_count.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # Utilities
-  #
-  module SeregaUtils
-    #
-    # Utility to count regular parameters of callable object
-    #
-    class ParamsCount
-      NO_NAMED_REST_PARAM = [:rest].freeze
-      private_constant :NO_NAMED_REST_PARAM
-
-      class << self
-        #
-        # Count parameters for callable object
-        #
-        # @param object [#call] callable object
-        #
-        # @return [Integer] count of regular parameters
-        #
-        def call(object, max_count:)
-          # Procs (but not lambdas) can accept all provided parameters
-          parameters = object.is_a?(Proc) ? object.parameters : object.method(:call).parameters
-          return 1 if parameters[0] == NO_NAMED_REST_PARAM
-          return max_count if object.is_a?(Proc) && !object.lambda?
-
-          count = 0
-
-          # If all we have is no-name *rest parameters, then we assume we need to provide
-          # 1 argument. It is now always correct, but in serialization context it's most common that
-          # only one argument is needed.
-          parameters.each do |parameter|
-            next if parameter == NO_NAMED_REST_PARAM # Workaround for procs like :odd?.to_proc
-            param_type = parameter[0]
-
-            case param_type
-            when :req then count += 1
-            when :opt then count += 1 if count < max_count
-            when :rest then count += max_count - count if max_count > count
-            end # else :opt, :keyreq, :key, :keyrest, :block - do nothing
-          end
-
-          count
-        end
-      end
-    end
-  end
-end

data/lib/serega/validations/utils/check_extra_keyword_arg.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaValidations
-    #
-    # Validations Utilities
-    #
-    module Utils
-      #
-      # Utility to check that callable object has no required keyword arguments
-      #
-      class CheckExtraKeywordArg
-        # Checks hash keys are allowed
-        #
-        # @param callable [#call] Callable object
-        # @param callable_description [Symbol] Callable object description
-        #
-        # @raise [Serega::SeregaError] error if callable accepts required keyword argument
-        #
-        # @return [void]
-        def self.call(callable, callable_description)
-          parameters = callable.is_a?(Proc) ? callable.parameters : callable.method(:call).parameters
-
-          parameters.each do |parameter|
-            next unless parameter[0] == :keyreq
-
-            raise Serega::SeregaError, "Invalid #{callable_description}. It should not have any required keyword arguments"
-          end
-        end
-      end
-    end
-  end
-end