serega 0.20.1 → 0.30.0

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin `:batch`
-    #
-    # Must be used to omit N+1 when loading attributes values.
-    #
-    # @example Quick example
-    #
-    #   class AppSerializer
-    #     plugin :batch, id_method: :id
-    #   end
-    #
-    #   class UserSerializer < AppSerializer
-    #     attribute :comments_count, batch: { loader: CommentsCountBatchLoader }, default: 0
-    #     attribute :company, serializer: CompanySerializer, batch: { loader: UserCompanyBatchLoader }
-    #   end
-    #
-    module Batch
-      # Returns plugin name
-      # @return [Symbol] Plugin name
-      def self.plugin_name
-        :batch
-      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 = %i[auto_hide id_method]
-        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_hide [Boolean] - Marks attribute as hidden when it has :batch loader specified\n" \
-            "  - :id_method [Symbol, #call] - Specified the default method to use to find object identifier"
-        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/batch_config"
-        require_relative "lib/loader"
-        require_relative "lib/loaders"
-        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/object_serializer"
-        require_relative "lib/modules/plan_point"
-        require_relative "lib/validations/check_batch_opt_id_method"
-        require_relative "lib/validations/check_batch_opt_loader"
-        require_relative "lib/validations/check_opt_batch"
-
-        serializer_class.extend(ClassMethods)
-        serializer_class.include(InstanceMethods)
-        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
-        serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
-        serializer_class::SeregaPlanPoint.include(PlanPointInstanceMethods)
-        serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
-      end
-
-      #
-      # Runs callbacks after plugin was attached
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] Plugin options
-      #
-      # @return [void]
-      #
-      def self.after_load_plugin(serializer_class, **opts)
-        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
-
-        batch_loaders_class = Class.new(SeregaBatchLoaders)
-        batch_loaders_class.serializer_class = serializer_class
-        serializer_class.const_set(:SeregaBatchLoaders, batch_loaders_class)
-
-        batch_loader_class = Class.new(SeregaBatchLoader)
-        batch_loader_class.serializer_class = serializer_class
-        serializer_class.const_set(:SeregaBatchLoader, batch_loader_class)
-
-        if serializer_class.plugin_used?(:activerecord_preloads)
-          require_relative "lib/plugins_extensions/activerecord_preloads"
-          serializer_class::SeregaBatchLoader.include(PluginsExtensions::ActiveRecordPreloads::BatchLoaderInstanceMethods)
-        end
-
-        if serializer_class.plugin_used?(:formatters)
-          require_relative "lib/plugins_extensions/formatters"
-          serializer_class::SeregaBatchLoader.include(PluginsExtensions::Formatters::BatchLoaderInstanceMethods)
-          serializer_class::SeregaAttribute.include(PluginsExtensions::Formatters::SeregaAttributeInstanceMethods)
-        end
-
-        if serializer_class.plugin_used?(:if)
-          require_relative "lib/plugins_extensions/if"
-          serializer_class::SeregaObjectSerializer.include(PluginsExtensions::If::ObjectSerializerInstanceMethods123)
-        end
-
-        if serializer_class.plugin_used?(:preloads)
-          require_relative "lib/plugins_extensions/preloads"
-          serializer_class::SeregaAttributeNormalizer.include(PluginsExtensions::Preloads::AttributeNormalizerInstanceMethods)
-        end
-
-        config = serializer_class.config
-        config.attribute_keys << :batch
-        config.opts[:batch] = {loaders: {}, id_method: nil, auto_hide: false}
-        config.batch.auto_hide = opts[:auto_hide] if opts.key?(:auto_hide)
-        config.batch.id_method = opts[:id_method] if opts.key?(:id_method)
-      end
-
-      #
-      # Serega class additional/patched class methods
-      #
-      # @see Serega::SeregaConfig
-      #
-      module ClassMethods
-        private
-
-        def inherited(subclass)
-          super
-
-          batch_loaders_class = Class.new(self::SeregaBatchLoaders)
-          batch_loaders_class.serializer_class = subclass
-          subclass.const_set(:SeregaBatchLoaders, batch_loaders_class)
-
-          batch_loader_class = Class.new(self::SeregaBatchLoader)
-          batch_loader_class.serializer_class = subclass
-          subclass.const_set(:SeregaBatchLoader, batch_loader_class)
-        end
-      end
-
-      #
-      # Serega additional/patched instance methods
-      #
-      # @see Serega::InstanceMethods
-      #
-      module InstanceMethods
-        private
-
-        #
-        # Loads batch loaded attributes after serialization
-        #
-        def serialize(object, opts)
-          batch_loaders = opts[:batch_loaders] = self.class::SeregaBatchLoaders.new
-          result = super
-          batch_loaders.load_all
-          result
-        end
-      end
-    end
-
-    register_plugin(Batch.plugin_name, Batch)
-  end
-end

data/lib/serega/plugins/batch/lib/batch_config.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Batch plugin config
-      #
-      class BatchConfig
-        attr_reader :opts
-
-        def initialize(opts)
-          @opts = opts
-        end
-
-        #
-        # Defines batch loader
-        #
-        # @param loader_name [Symbol] Batch loader name, that is used when defining attribute with batch loader.
-        # @param block [Proc] Block that can accept 3 parameters - ids, context, plan_point
-        #   and returns hash with ids as keys and values are batch loaded objects
-        #
-        # @return [void]
-        #
-        def define(loader_name, callable = nil, &block)
-          if (!callable && !block) || (callable && block)
-            raise SeregaError, "Batch loader can be specified with one of arguments - callable value or &block"
-          end
-
-          callable ||= block
-          SeregaValidations::Utils::CheckExtraKeywordArg.call(callable, "batch loader `#{loader_name}`")
-          params_count = SeregaUtils::ParamsCount.call(callable, max_count: 3)
-
-          if params_count > 3
-            raise SeregaError, "Batch loader can have maximum 3 parameters (ids, context, plan)"
-          end
-
-          loaders[loader_name] = callable
-        end
-
-        # Shows defined loaders
-        # @return [Hash] defined loaders
-        def loaders
-          opts[:loaders]
-        end
-
-        # Shows option to auto hide attributes with :batch specified
-        # @return [Boolean, nil] option value
-        def auto_hide
-          opts[:auto_hide]
-        end
-
-        # @param value [Boolean] New :auto_hide option value
-        # @return [Boolean] New option value
-        def auto_hide=(value)
-          raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
-          opts[:auto_hide] = value
-        end
-
-        # Shows method name or callable object needed to get object identifier for batch load
-        # @return [Symbol, #call, nil] Default method name or callable object to get identifier
-        def id_method
-          opts[:id_method]
-        end
-
-        # Sets new identifier method name or callable value needed for batch loading
-        #
-        # @param value [Symbol, #call] New :id_method value
-        # @return [Boolean] New option value
-        def id_method=(value)
-          CheckBatchOptIdMethod.call(value)
-          opts[:id_method] = value
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/loader.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Encapsulates point and according object_serializer
-      #   so we can put batch loaded values to this serializer response
-      #
-      class SeregaBatchLoader
-        #
-        # Batch Loader instance methods
-        #
-        module InstanceMethods
-          # @return [Serega::SeregaPlanPoint]
-          attr_reader :point
-
-          # @return [Serega::SeregaObjectSerializer]
-          attr_reader :object_serializer
-
-          #
-          # Initializes new SeregaBatchLoader
-          #
-          # @param object_serializer [Serega::SeregaObjectSerializer]
-          # @param point [Serega::SeregaPlanPoint]
-          #
-          # @return [Serega::SeregaPlugins::Batch::SeregaBatchLoader]
-          #
-          def initialize(object_serializer, point)
-            @object_serializer = object_serializer
-            @point = point
-          end
-
-          #
-          # Remembers key and hash container where value for this key must be inserted
-          #
-          # @param key [Object] key that identifies batch loaded objects
-          # @param container [Hash] container where batch loaded objects must be attached
-          #
-          # @return [void]
-          #
-          def remember(key, container)
-            (keys[key] ||= []) << container
-          end
-
-          #
-          # Loads this batch and assigns values to remembered containers
-          #
-          # @return [void]
-          #
-          def load
-            keys_values = keys_values()
-
-            each_key do |key, container|
-              value = keys_values.fetch(key) { point.batch[:default] }
-              final_value = object_serializer.__send__(:final_value, value, point)
-              object_serializer.__send__(:attach_final_value, final_value, point, container)
-            end
-          end
-
-          private
-
-          def keys
-            @keys ||= {}
-          end
-
-          def each_key
-            keys.each do |key, containers|
-              containers.each do |container|
-                yield(key, container)
-              end
-            end
-          end
-
-          # Patched in:
-          # - plugin batch (extension :activerecord_preloads - preloads data to found values)
-          # - plugin batch (extension :formatters - formats values)
-          def keys_values
-            ids = keys.keys
-
-            keys_values = load_keys_values(ids)
-            validate(keys_values)
-
-            keys_values
-          end
-
-          def load_keys_values(ids)
-            point.batch[:loader].call(ids, object_serializer.context, point)
-          rescue => error
-            raise reraise_with_serialized_attribute_details(error, point)
-          end
-
-          def validate(keys_values)
-            return if keys_values.is_a?(Hash)
-
-            attribute_name = "#{point.class.serializer_class}.#{point.name}"
-            raise SeregaError, "Batch loader for `#{attribute_name}` must return Hash, but #{keys_values.inspect} was returned"
-          end
-
-          def reraise_with_serialized_attribute_details(error, point)
-            raise error.exception(<<~MESSAGE.strip)
-              #{error.message}
-              (when serializing '#{point.name}' attribute in #{self.class.serializer_class})
-            MESSAGE
-          end
-        end
-
-        include InstanceMethods
-        extend Serega::SeregaHelpers::SerializerClassHelper
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/loaders.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      # Lists batch loaders registered during serialization
-      class SeregaBatchLoaders
-        # BatchLoaders instance methods
-        module InstanceMethods
-          #
-          # Initializes or fetches already initialized batch loader
-          #
-          # @param plan_point [Serega::SeregaPlanPoint] current plan point
-          # @param object_serializer[Serega::SeregaObjectSerializer] current object serializer
-          #
-          # @return [Serega::SeregaPlugins::Batch::SeregaBatchLoader] Batch Loader
-          #
-          def get(plan_point, object_serializer)
-            batch_loaders[plan_point] ||= self.class.serializer_class::SeregaBatchLoader.new(object_serializer, plan_point)
-          end
-
-          #
-          # Loads all registered batches and removes them from registered list
-          #
-          def load_all
-            return unless defined?(@batch_loaders)
-
-            while (_point, batch_loader = batch_loaders.shift)
-              batch_loader.load
-            end
-          end
-
-          private
-
-          def batch_loaders
-            @batch_loaders ||= {}.compare_by_identity
-          end
-        end
-
-        include InstanceMethods
-        extend Serega::SeregaHelpers::SerializerClassHelper
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Serega::SeregaAttribute additional/patched class methods
-      #
-      # @see Serega::SeregaAttribute
-      #
-      module AttributeInstanceMethods
-        #
-        # @return [nil, Hash] :batch option
-        #
-        attr_reader :batch
-
-        private
-
-        def set_normalized_vars(normalizer)
-          super
-          @batch = normalizer.batch
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # SeregaAttributeNormalizer additional/patched instance methods
-      #
-      # @see SeregaAttributeNormalizer::AttributeInstanceMethods
-      #
-      module AttributeNormalizerInstanceMethods
-        #
-        # Returns normalized attribute :batch option with prepared :key and
-        # :default options. Option :loader will be prepared at serialization
-        # time as loaders are usually defined after attributes.
-        #
-        # @return [Hash] attribute :batch normalized options
-        #
-        def batch
-          return @batch if instance_variable_defined?(:@batch)
-
-          @batch = prepare_batch
-        end
-
-        private
-
-        #
-        # Patch for original `prepare_hide` method
-        #
-        # Marks attribute hidden if auto_hide option was set and attribute has batch loader
-        #
-        def prepare_hide
-          res = super
-          return res unless res.nil?
-
-          if batch
-            self.class.serializer_class.config.batch.auto_hide || nil
-          end
-        end
-
-        def prepare_batch
-          batch = init_opts[:batch]
-          return unless batch
-
-          loader = prepare_batch_loader(batch[:loader])
-
-          id_method = batch[:id_method] || self.class.serializer_class.config.batch.id_method
-          id_method = prepare_batch_id_method(id_method)
-
-          {loader: loader, id_method: id_method, default: default}
-        end
-
-        def prepare_batch_id_method(id_method)
-          return proc { |object| object.public_send(id_method) } if id_method.is_a?(Symbol)
-
-          params_count = SeregaUtils::ParamsCount.call(id_method, max_count: 2)
-          case params_count
-          when 0 then proc { id_method.call }
-          when 1 then proc { |object| id_method.call(object) }
-          else id_method
-          end
-        end
-
-        def prepare_batch_loader(loader)
-          loader = self.class.serializer_class.config.batch.loaders.fetch(loader) if loader.is_a?(Symbol)
-
-          params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
-          case params_count
-          when 0 then proc { loader.call }
-          when 1 then proc { |object| loader.call(object) }
-          when 2 then proc { |object, context| loader.call(object, context) }
-          else loader
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Serega::SeregaValidations::CheckAttributeParams additional/patched class methods
-      #
-      # @see Serega::SeregaValidations::CheckAttributeParams
-      #
-      module CheckAttributeParamsInstanceMethods
-        private
-
-        def check_opts
-          super
-
-          CheckOptBatch.call(opts, block, self.class.serializer_class)
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Config class additional/patched instance methods
-      #
-      # @see Serega::SeregaConfig
-      #
-      module ConfigInstanceMethods
-        #
-        # Returns all batch loaders registered for current serializer
-        #
-        # @return [Serega::SeregaPlugins::Batch::BatchConfig] configuration for batch loaded attributes
-        #
-        def batch
-          @batch ||= BatchConfig.new(opts.fetch(:batch))
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/batch/lib/modules/object_serializer.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # SeregaObjectSerializer additional/patched class methods
-      #
-      # @see Serega::SeregaObjectSerializer
-      #
-      module SeregaObjectSerializerInstanceMethods
-        private
-
-        def attach_value(object, point, container)
-          batch = point.batch
-          return super unless batch
-
-          remember_key_for_batch_loading(batch, object, point, container)
-        end
-
-        def remember_key_for_batch_loading(batch, object, point, container)
-          id = batch[:id_method].call(object, context)
-          batch_loader(point).remember(id, container)
-          container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
-        end
-
-        def batch_loader(point)
-          batch_loaders = opts[:batch_loaders]
-          raise_batch_plugin_for_serializer_not_defined(point) unless batch_loaders
-          batch_loaders.get(point, self)
-        end
-
-        def raise_batch_plugin_for_serializer_not_defined(point)
-          root_plan = point.plan
-          root_plan = plan.parent_plan_point.plan while root_plan.parent_plan_point
-          current_serializer = root_plan.serializer_class
-          nested_serializer = self.class.serializer_class
-
-          raise SeregaError,
-            "Plugin :batch must be added to current serializer (#{current_serializer})" \
-            " to load attributes with :batch option in nested serializer (#{nested_serializer})"
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Batch
-      #
-      # Serega::SeregaPlanPoint additional/patched class methods
-      #
-      # @see SeregaAttribute
-      #
-      module PlanPointInstanceMethods
-        #
-        # Returns attribute :batch option with prepared loader
-        # @return [Hash] attribute :batch option
-        #
-        def batch
-          attribute.batch
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +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 :active_record_preloads plugin
-        #
-        module ActiveRecordPreloads
-          #
-          # BatchLoader additional/patched instance methods
-          #
-          # @see Serega::SeregaPlugins::Batch::SeregaBatchLoader
-          #
-          module BatchLoaderInstanceMethods
-            private
-
-            # Preloads required associations to batch-loaded records
-            def keys_values
-              data = super
-
-              if point.child_plan
-                associations = point.preloads
-                return data if associations.empty?
-
-                records = data.values
-                records.flatten!(1)
-
-                ActiverecordPreloads::Preloader.preload(records, associations)
-              end
-
-              data
-            end
-          end
-        end
-      end
-    end
-  end
-end