serega 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1aec10f062296a0af1d3f6b445f189ab2d84a145a8ed3cf0d52c81aa0c4f2c69
-  data.tar.gz: 1038ea10d7ea09b25d8f74b0561319d6f518a447121686ed689ff16385ec8806
+  metadata.gz: 5ed53d558202f013db9523c47d0d66f7c1122e5ef6cccebe590af9f53733e79c
+  data.tar.gz: ff3a809f7b783c4585c378d49d64f070db2c62952c574f7a9eff4a2928bab76c
 SHA512:
-  metadata.gz: 8d568f45860671e760f56f67fd8206b2476b97ee5d415e881f23c9226285ef5b99a87b12ebd5da552664b6cd345ccb90cf7d43e10ed2a563ef436159f81afec5
-  data.tar.gz: 3100f9a6bd3b8fba77175677d4e53c01abf467cf2c57a5c1eea6a71ac2fbd73e7d2c0b0ff7071a032acdd73e6b37af37cc3259421e4fc58a96d5400fdea215ed
+  metadata.gz: 50de7bfab75d1da976496e86fab440b295cc4c728a5692f1c5126bd76fab1b8c09ddb3de8d0adb3e89e269c79b70a98c41396334e1c8d3e1ecf805e6907b25e1
+  data.tar.gz: ad6d8e4b386bd44d54a90415829797b09b36ddcf22b8234ccaac453e0b6ff2b9ab4a107f5df6a7060b75fa7d0ed8a2ef4cc0e00f11861109c1b1005b61b83936

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lib/serega/attribute.rb

@@ -77,7 +77,12 @@ class Serega
       def value_block
         return @value_block if instance_variable_defined?(:@value_block)
 
-        @value_block = block || opts[:value] || const_block || delegate_block || keyword_block
+        @value_block =
+          block ||
+          opts[:value] ||
+          const_block ||
+          delegate_block ||
+          keyword_block
       end
 
       #

data/lib/serega/config.rb

@@ -15,8 +15,8 @@ class Serega
       serialize_keys: %i[context many].freeze,
       check_initiate_params: true,
       max_cached_map_per_serializer_count: 0,
-      to_json: SeregaJSON.adapter == :oj ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
-      from_json: SeregaJSON.adapter == :oj ? SeregaJSON::OjLoad : SeregaJSON::JSONLoad
+      to_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
+      from_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjLoad : SeregaJSON::JSONLoad
     }.freeze
     # :nocov:
 

data/lib/serega/map.rb

@@ -36,7 +36,7 @@ class Serega
         serializer_class.attributes.each_with_object([]) do |(name, attribute), map|
           next unless attribute.visible?(only: only, except: except, with: with)
 
-          nested_map =
+          nested_points =
             if attribute.relation?
               construct_map(
                 attribute.serializer,
@@ -44,11 +44,9 @@ class Serega
                 with: with[name] || FROZEN_EMPTY_HASH,
                 except: except[name] || FROZEN_EMPTY_HASH
               )
-            else
-              FROZEN_EMPTY_ARRAY
             end
 
-          map << [attribute, nested_map]
+          map << serializer_class::SeregaMapPoint.new(attribute, nested_points)
         end
       end
     end

data/lib/serega/map_point.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Serega
+  class SeregaMapPoint
+    module InstanceMethods
+      extend Forwardable
+
+      attr_reader :attribute, :nested_points
+
+      def_delegators :@attribute, :name, :value, :many
+
+      def initialize(attribute, nested_points)
+        @attribute = attribute
+        @nested_points = nested_points
+      end
+
+      def has_nested_points?
+        !nested_points.nil?
+      end
+
+      def nested_object_serializer
+        attribute.serializer::SeregaObjectSerializer
+      end
+
+      # TODO: remove, we use this method in tests only
+      def ==(other)
+        (other.attribute == attribute) && (other.nested_points == nested_points)
+      end
+    end
+
+    extend Serega::SeregaHelpers::SerializerClassHelper
+    include InstanceMethods
+  end
+end

data/lib/serega/object_serializer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Serega
+  class SeregaObjectSerializer
+    module SeregaObjectSerializerInstanceMethods
+      attr_reader :context, :points, :many, :opts
+
+      # @param context [Hash] Serialization context
+      # @param many [TrueClass|FalseClass] is object is enumerable
+      # @param points [Array<MapPoint>] Serialization points (attributes)
+      def initialize(context:, points:, many: nil, **opts)
+        @context = context
+        @points = points
+        @many = many
+        @opts = opts
+      end
+
+      # @param object [Object] Serialized object
+      def serialize(object)
+        array?(object, many) ? serialize_array(object) : serialize_object(object)
+      end
+
+      private
+
+      def serialize_array(object)
+        object.map { |obj| serialize_object(obj) }
+      end
+
+      def serialize_object(object)
+        return unless object
+
+        points.each_with_object({}) do |point, container|
+          attach_value(object, point, container)
+        end
+      end
+
+      def attach_value(object, point, container)
+        value = point.value(object, context)
+        final_value = final_value(value, point)
+        attach_final_value(final_value, point, container)
+      end
+
+      def attach_final_value(final_value, point, container)
+        container[point.name] = final_value
+      end
+
+      def final_value(value, point)
+        point.has_nested_points? ? relation_value(value, point) : value
+      end
+
+      def relation_value(value, point)
+        nested_points = point.nested_points
+        nested_serializer = point.nested_object_serializer
+        nested_many = point.many
+        serializer = nested_serializer.new(context: context, points: nested_points, many: nested_many, **opts)
+        serializer.serialize(value)
+      end
+
+      def array?(object, many)
+        many.nil? ? object.is_a?(Enumerable) : many
+      end
+    end
+
+    extend Serega::SeregaHelpers::SerializerClassHelper
+    include SeregaObjectSerializerInstanceMethods
+  end
+end

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

@@ -14,6 +14,10 @@ class Serega
       end
 
       def self.before_load_plugin(serializer_class, **opts)
+        if serializer_class.plugin_used?(:batch)
+          raise SeregaError, "Plugin `activerecord_preloads` must be loaded before `batch`"
+        end
+
         serializer_class.plugin(:preloads, **opts) unless serializer_class.plugin_used?(:preloads)
       end
 

data/lib/serega/plugins/activerecord_preloads/lib/preloader.rb

@@ -6,6 +6,8 @@ class Serega
       class Preloader
         module ClassMethods
           def preload(object, preloads)
+            return object if object.nil? || (object.is_a?(Array) && object.empty?) || preloads.empty?
+
             preload_handler = handlers.find { |handler| handler.fit?(object) }
             raise SeregaError, "Can't preload #{preloads.inspect} to #{object.inspect}" unless preload_handler
 
@@ -13,7 +15,12 @@ class Serega
           end
 
           def handlers
-            @handlers ||= [ActiverecordRelation, ActiverecordObject, ActiverecordArray].freeze
+            @handlers ||= [
+              ActiverecordRelation,
+              ActiverecordObject,
+              ActiverecordArray,
+              ActiverecordEnumerator
+            ].freeze
           end
         end
 
@@ -54,13 +61,9 @@ class Serega
           end
 
           def preload(objects, preloads)
-            if objects.loaded?
-              array_objects = objects.to_a
-              Loader.call(array_objects, preloads)
-              objects
-            else
-              objects.preload(preloads).load
-            end
+            objects.load
+            Loader.call(objects.to_a, preloads)
+            objects
           end
         end
 
@@ -90,6 +93,22 @@ class Serega
 
         extend ClassMethods
       end
+
+      class ActiverecordEnumerator
+        module ClassMethods
+          def fit?(objects)
+            objects.is_a?(Enumerator) &&
+              ActiverecordArray.fit?(objects.to_a)
+          end
+
+          def preload(objects, preloads)
+            ActiverecordArray.preload(objects.to_a, preloads)
+            objects
+          end
+        end
+
+        extend ClassMethods
+      end
     end
   end
 end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      def self.plugin_name
+        :batch
+      end
+
+      def self.load_plugin(serializer_class, **_opts)
+        require_relative "./lib/loader"
+        require_relative "./lib/loaders"
+        require_relative "./lib/validations/check_batch_opt_key"
+        require_relative "./lib/validations/check_batch_opt_loader"
+        require_relative "./lib/validations/check_opt_batch"
+
+        serializer_class.extend(ClassMethods)
+        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
+        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
+        serializer_class::SeregaMapPoint.include(MapPointInstanceMethods)
+        serializer_class::SeregaSerializer.include(SeregaSerializerInstanceMethods)
+        serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
+      end
+
+      def self.after_load_plugin(serializer_class, **opts)
+        config = serializer_class.config
+        config.attribute_keys << :batch
+        config.opts[:batch] = {loaders: {}}
+        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"
+          serializer_class::SeregaBatchLoader.include(PluginsExtensions::ActiveRecordPreloads::BatchLoaderInstanceMethods)
+        end
+
+        if serializer_class.plugin_used?(:formatters)
+          require_relative "./lib/plugins_extensions"
+          serializer_class::SeregaBatchLoader.include(PluginsExtensions::Formatters::BatchLoaderInstanceMethods)
+        end
+      end
+
+      class BatchLoadersConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def define(loader_name, &block)
+          unless block
+            raise SeregaError, "Block must be given to batch_loaders.define method"
+          end
+
+          params = block.parameters
+          if params.count > 3 || !params.map!(&:first).all? { |type| (type == :req) || (type == :opt) }
+            raise SeregaError, "Block can have maximum 3 regular parameters"
+          end
+
+          opts[loader_name] = block
+        end
+
+        def fetch(loader_name)
+          opts[loader_name] || (raise SeregaError, "Batch loader with name `#{loader_name.inspect}` was not defined. Define example: config.batch_loaders.define(:#{loader_name}) { |keys, ctx, points| ... }")
+        end
+      end
+
+      class BatchModel
+        attr_reader :opts, :loaders, :many
+
+        def initialize(opts, loaders, many)
+          @opts = opts
+          @loaders = loaders
+          @many = many
+        end
+
+        def loader
+          @batch_loader ||= begin
+            loader = opts[:loader]
+            loader = loaders.fetch(loader) if loader.is_a?(Symbol)
+            loader
+          end
+        end
+
+        def key
+          @batch_key ||= begin
+            key = opts[:key]
+            key.is_a?(Symbol) ? proc { |object| object.public_send(key) } : key
+          end
+        end
+
+        def default_value
+          if opts.key?(:default)
+            opts[:default]
+          elsif many
+            FROZEN_EMPTY_ARRAY
+          end
+        end
+      end
+
+      module ConfigInstanceMethods
+        def batch_loaders
+          @batch_loaders ||= BatchLoadersConfig.new(opts.fetch(:batch).fetch(:loaders))
+        end
+      end
+
+      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
+
+      module CheckAttributeParamsInstanceMethods
+        def check_opts
+          super
+
+          CheckOptBatch.call(opts, block)
+        end
+      end
+
+      module AttributeInstanceMethods
+        def batch
+          opts[:batch]
+        end
+      end
+
+      module MapPointInstanceMethods
+        def batch
+          return @batch if instance_variable_defined?(:@batch)
+
+          @batch = begin
+            opts = attribute.batch
+            BatchModel.new(opts, self.class.serializer_class.config.batch_loaders, many) if opts
+          end
+        end
+      end
+
+      module SeregaSerializerInstanceMethods
+        def initialize(**_args)
+          super
+          opts[:batch_loaders] = self.class.serializer_class::SeregaBatchLoaders.new
+        end
+
+        def serialize(*)
+          result = super
+
+          opts[:batch_loaders].load_all
+
+          result
+        end
+      end
+
+      module SeregaObjectSerializerInstanceMethods
+        private
+
+        def attach_value(object, point, container)
+          batch = point.batch
+
+          if batch
+            key = batch.key.call(object, context)
+            opts[:batch_loaders].get(point, self).remember(key, container)
+            container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(Batch.plugin_name, Batch)
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      class SeregaBatchLoader
+        module InstanceMethods
+          attr_reader :object_serializer, :point
+
+          def initialize(object_serializer, point)
+            @object_serializer = object_serializer
+            @point = point
+          end
+
+          def remember(key, container)
+            (keys[key] ||= []) << container
+          end
+
+          def load
+            keys_values = keys_values()
+
+            each_key do |key, container|
+              value = keys_values.fetch(key) { point.batch.default_value }
+              final_value = object_serializer.__send__(:final_value, value, point)
+              object_serializer.__send__(:attach_final_value, final_value, point, container)
+            end
+          end
+
+          private
+
+          def each_key
+            keys.each do |key, containers|
+              containers.each do |container|
+                yield(key, container)
+              end
+            end
+          end
+
+          def keys_values
+            ids = keys.keys
+
+            point.batch.loader.call(ids, object_serializer.context, point.nested_points).tap do |vals|
+              next if vals.is_a?(Hash)
+
+              attribute_name = "#{point.class.serializer_class}.#{point.name}"
+              raise SeregaError, "Batch loader for `#{attribute_name}` must return Hash, but #{vals.inspect} was returned"
+            end
+          end
+
+          def keys
+            @keys ||= {}
+          end
+        end
+
+        include InstanceMethods
+        extend Serega::SeregaHelpers::SerializerClassHelper
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      class SeregaBatchLoaders
+        module InstanceMethods
+          def get(point, object_serializer)
+            batch_loaders[point] ||= self.class.serializer_class::SeregaBatchLoader.new(object_serializer, point)
+          end
+
+          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/plugins_extensions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      module PluginsExtensions
+        module ActiveRecordPreloads
+          module BatchLoaderInstanceMethods
+            def keys_values(*)
+              data = super
+
+              if point.has_nested_points?
+                associations = point.preloads
+                return data if associations.empty?
+
+                ActiverecordPreloads::Preloader.preload(data.values.flatten(1), associations)
+              end
+
+              data
+            end
+          end
+        end
+
+        module Formatters
+          module BatchLoaderInstanceMethods
+            # Format values after they are prepared
+            def keys_values(*)
+              data = super
+
+              formatter = point.attribute.formatter_resolved
+              data.transform_values! { |value| formatter.call(value) } if formatter
+
+              data
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      class CheckBatchOptKey
+        class << self
+          def call(key)
+            return if key.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless key.respond_to?(:call)
+
+            if key.is_a?(Proc)
+              check_block(key)
+            else
+              check_callable(key)
+            end
+          end
+
+          private
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..2)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid :batch option :key. When it is a Proc it can have maximum two regular parameters (object, context)"
+          end
+
+          def callable_parameters_error
+            "Invalid :batch option :key. When it is a callable object it must have two regular parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid :batch option :key. 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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      class CheckBatchOptLoader
+        class << self
+          def call(loader)
+            return if loader.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless loader.respond_to?(:call)
+
+            if loader.is_a?(Proc)
+              check_block(loader)
+            else
+              check_callable(loader)
+            end
+          end
+
+          private
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..3)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 3..3)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid :batch option :loader. When it is a Proc it can have maximum three regular parameters (keys, context, points)"
+          end
+
+          def callable_parameters_error
+            "Invalid :batch option :loader. When it is a callable object it must have three regular parameters (keys, context, points)"
+          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