serega 0.20.1 → 0.30.0

data/lib/serega/plugins/batch/lib/plugins_extensions/formatters.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
-      #
-      module PluginsExtensions
-        #
-        # Extension that is used when batch plugin used with :formatters plugin
-        #
-        module Formatters
-          #
-          # BatchLoader additional/patched instance methods
-          #
-          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
-          #
-          module BatchLoaderInstanceMethods
-            private
-
-            # Format values after they are prepared
-            def keys_values
-              data = super
-
-              formatter = point.attribute.formatter
-              data.transform_values! { |value| formatter.call(value) } if formatter
-
-              data
-            end
-          end
-
-          #
-          # SeregaAttribute additional/patched instance methods
-          #
-          # @see Serega::SeregaAttribute
-          #
-          module SeregaAttributeInstanceMethods
-            # Normalized formatter block or callable instance
-            # @return [#call, nil] Normalized formatter block or callable instance
-            attr_reader :formatter
-
-            private
-
-            def set_normalized_vars(normalizer)
-              super
-              @formatter = normalizer.formatter
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/plugins_extensions/if.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
-      #
-      module PluginsExtensions
-        #
-        # Extension that is used when :if plugin is loaded
-        #
-        module If
-          #
-          # SeregaObjectSerializer additional/patched class methods
-          #
-          # @see Serega::SeregaObjectSerializer
-          #
-          module ObjectSerializerInstanceMethods123
-            private
-
-            # Removes key added by `batch` plugin at the start of serialization to preserve attributes ordering
-            def attach_final_value(value, point, container)
-              container.delete(point.name) if super == SeregaPlugins::If::KEY_SKIPPED
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Extensions (mini-plugins) that are enabled when :batch plugin used with other plugins
-      #
-      module PluginsExtensions
-        #
-        # Extension that is used when :preloads plugin is loaded
-        #
-        module Preloads
-          #
-          # Attribute additional/patched instance methods
-          #
-          # @see Serega::SeregaPlugins::Preloads::AttributeNormalizerInstanceMethods
-          #
-          module AttributeNormalizerInstanceMethods
-            private
-
-            # Do not add any preloads automatically when batch option provided
-            def prepare_preloads
-              opts = init_opts
-              return if opts.key?(:batch) && !opts.key?(:preload)
-
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/validations/check_batch_opt_id_method.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Validator for option :id_method in attribute :batch option
-      #
-      class CheckBatchOptIdMethod
-        class << self
-          #
-          # Checks option :id_method of attribute :batch option
-          #
-          # @param id [nil, #call] Attribute :batch option :id_method
-          #
-          # @raise [SeregaError] validation error
-          #
-          # @return [void]
-          #
-          def call(id)
-            return if id.is_a?(Symbol)
-
-            raise SeregaError, must_be_callable unless id.respond_to?(:call)
-
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(id, "batch option :id_method")
-            params_count = SeregaUtils::ParamsCount.call(id, max_count: 2)
-            raise SeregaError, params_count_error if params_count > 2
-          end
-
-          private
-
-          def params_count_error
-            "Invalid :batch option :id_method. It can accept maximum 2 parameters (object, context)"
-          end
-
-          def must_be_callable
-            "Invalid :batch option :id_method. It must be a Symbol, a Proc or respond to #call"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/validations/check_batch_opt_loader.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Validator for option :loader in attribute :batch option
-      #
-      class CheckBatchOptLoader
-        class << self
-          #
-          # Checks option :loader of attribute :batch option
-          #
-          # @param loader [nil, #call] Attribute :batch option :loader
-          #
-          # @raise [SeregaError] validation error
-          #
-          # @return [void]
-          #
-          def call(loader, serializer_class)
-            if loader.is_a?(Symbol)
-              check_symbol(loader, serializer_class)
-            else
-              check_callable(loader)
-            end
-          end
-
-          private
-
-          def check_symbol(loader_name, serializer_class)
-            defined_loaders = serializer_class.config.batch.loaders
-            return if defined_loaders[loader_name]
-
-            raise SeregaError, <<~ERR.strip
-              Please define loader before adding it to attribute.
-                Example: `config.batch.define(:#{loader_name}) { |ids| ... }`
-            ERR
-          end
-
-          def check_callable(loader)
-            raise SeregaError, must_be_callable unless loader.respond_to?(:call)
-
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(loader, ":batch option :loader")
-            params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
-            raise SeregaError, params_count_error if params_count > 3
-          end
-
-          def params_count_error
-            "Invalid :batch option :loader. It can accept maximum 3 parameters (ids, context, plan)"
-          end
-
-          def must_be_callable
-            "Invalid :batch option :loader. It must be a Symbol, a Proc or respond to :call"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/validations/check_opt_batch.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Attribute `:batch` option validator
-      #
-      class CheckOptBatch
-        class << self
-          #
-          # Checks attribute :batch  option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] Attribute validation error
-          #
-          # @return [void]
-          #
-          def call(opts, block, serializer_class)
-            return unless opts.key?(:batch)
-
-            SeregaValidations::Utils::CheckOptIsHash.call(opts, :batch)
-
-            batch = opts[:batch]
-            SeregaValidations::Utils::CheckAllowedKeys.call(batch, %i[id_method loader], :batch)
-
-            check_batch_opt_id_method(batch, serializer_class)
-            check_batch_opt_loader(batch, serializer_class)
-            check_usage_with_other_params(opts, block)
-          end
-
-          private
-
-          def check_batch_opt_id_method(batch, serializer_class)
-            return if !batch.key?(:id_method) && serializer_class.config.batch.id_method
-
-            id_method = batch[:id_method]
-            raise SeregaError, "Option :id_method must present inside :batch option" unless id_method
-
-            CheckBatchOptIdMethod.call(id_method)
-          end
-
-          def check_batch_opt_loader(batch, serializer_class)
-            loader = batch[:loader]
-            raise SeregaError, "Option :loader must present inside :batch option" unless loader
-
-            CheckBatchOptLoader.call(loader, serializer_class)
-          end
-
-          def check_usage_with_other_params(opts, block)
-            raise SeregaError, "Option :batch can not be used together with option :method" if opts.key?(:method)
-            raise SeregaError, "Option :batch can not be used together with option :value" if opts.key?(:value)
-            raise SeregaError, "Option :batch can not be used together with option :const" if opts.key?(:const)
-            raise SeregaError, "Option :batch can not be used together with option :delegate" if opts.key?(:delegate)
-            raise SeregaError, "Option :batch can not be used together with block" if block
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Preloads
-      #
-      # Utility that helps to transform user provided preloads to hash
-      #
-      class FormatUserPreloads
-        class << self
-          #
-          # Transforms user provided preloads to hash
-          #
-          # @param value [Array,Hash,String,Symbol,nil,false] preloads
-          #
-          # @return [Hash] preloads transformed to hash
-          #
-          def call(value)
-            case value
-            when Array then array_to_hash(value)
-            when FalseClass then nil_to_hash(value)
-            when Hash then hash_to_hash(value)
-            when NilClass then nil_to_hash(value)
-            when String then string_to_hash(value)
-            when Symbol then symbol_to_hash(value)
-            else raise Serega::SeregaError,
-              "Preload option value can consist from Symbols, Arrays, Hashes (#{value.class} #{value.inspect} was provided)"
-            end
-          end
-
-          private
-
-          def array_to_hash(values)
-            values.each_with_object({}) do |value, obj|
-              obj.merge!(call(value))
-            end
-          end
-
-          def hash_to_hash(values)
-            values.each_with_object({}) do |(key, value), obj|
-              obj[key.to_sym] = call(value)
-            end
-          end
-
-          def nil_to_hash(_value)
-            {}
-          end
-
-          def string_to_hash(value)
-            {value.to_sym => {}}
-          end
-
-          def symbol_to_hash(value)
-            {value => {}}
-          end
-        end
-      end
-    end
-  end
-end

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

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

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