serega 0.10.0 → 0.11.0

data/VERSION

@@ -1 +1 @@
-0.10.0
+0.11.0

data/lib/serega/attribute.rb

@@ -9,98 +9,62 @@ class Serega
     # Attribute instance methods
     #
     module AttributeInstanceMethods
-      # Returns attribute name
+      # Attribute initial params
+      # @return [Hash] Attribute initial params
+      attr_reader :initials
+
+      # Attribute name
       # @return [Symbol] Attribute name
       attr_reader :name
 
-      # Returns attribute options
-      # @return [Hash] Attribute options
-      attr_reader :opts
+      # Attribute :many option
+      # @return [Boolean, nil] Attribute :many option
+      attr_reader :many
 
-      # Returns attribute block
-      # @return [Proc] Attribute originally added block
-      attr_reader :block
+      # Attribute :hide option
+      # @return [Boolean nil] Attribute :hide option
+      attr_reader :hide
 
       #
       # Initializes new attribute
       #
       # @param name [Symbol, String] Name of attribute
-      #
       # @param opts [Hash] Attribute options
-      # @option opts [Symbol] :key Object instance method name to get attribute value
-      # @option opts [Boolean] :exposed Configures if we should serialize this attribute by default.
-      #  (by default is true for regular attributes and false for relationships)
+      # @option opts [Symbol] :key Object method name to fetch attribute value
+      # @option opts [Hash] :delegate Allows to fetch value from nested object
+      # @option opts [Boolean] :hide Specify `true` to not serialize this attribute by default
       # @option opts [Boolean] :many Specifies has_many relationship. By default is detected via object.is_a?(Enumerable)
-      # @option opts [Serega, Proc] :serializer Relationship serializer class. Use `proc { MySerializer }` if serializers have cross references.
-      #
-      # @param block [Proc] Proc that receives object and context and finds attribute value
+      # @option opts [Proc, #call] :value Custom block or callable to find attribute value
+      # @option opts [Serega, Proc] :serializer Relationship serializer class. Use `proc { MySerializer }` if serializers have cross references
+      # @param block [Proc] Custom block to find attribute value
       #
       def initialize(name:, opts: {}, block: nil)
-        self.class.serializer_class::CheckAttributeParams.new(name, opts, block).validate
-
-        @name = name.to_sym
-        @opts = SeregaUtils::EnumDeepDup.call(opts)
-        @block = block
-      end
+        serializer_class = self.class.serializer_class
+        serializer_class::CheckAttributeParams.new(name, opts, block).validate
 
-      # Method name that will be used to get attribute value
-      #
-      # @return [Symbol] key
-      def key
-        @key ||= opts.key?(:key) ? opts[:key].to_sym : name
-      end
-
-      # Shows current opts[:hide] option
-      #
-      # Patched in:
-      # - plugin :preloads (returns true by default if config option auto_hide_attribute_with_preloads is enabled)
-      #
-      # @return [Boolean, nil] Attribute :hide option value
-      def hide
-        opts[:hide]
-      end
+        @initials = SeregaUtils::EnumDeepFreeze.call(
+          name: name,
+          opts: SeregaUtils::EnumDeepDup.call(opts),
+          block: block
+        )
 
-      # Shows current opts[:many] option
-      # @return [Boolean, nil] Attribute :many option value
-      def many
-        opts[:many]
+        normalizer = serializer_class::SeregaAttributeNormalizer.new(initials)
+        set_normalized_vars(normalizer)
       end
 
       # Shows whether attribute has specified serializer
       # @return [Boolean] Checks if attribute is relationship (if :serializer option exists)
       def relation?
-        !opts[:serializer].nil?
+        !@serializer.nil?
       end
 
       # Shows specified serializer class
       # @return [Serega, nil] Attribute serializer if exists
       def serializer
-        return @serializer if instance_variable_defined?(:@serializer)
-
-        serializer = opts[:serializer]
-        @serializer =
-          case serializer
-          when String then Object.const_get(serializer, false)
-          when Proc then serializer.call
-          else serializer
-          end
-      end
+        ser = @serializer
+        return ser if (ser.is_a?(Class) && (ser < Serega)) || !ser
 
-      # Returns final block used to find attribute value
-      #
-      # Patched in:
-      # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
-      #
-      # @return [Proc] Proc to find attribute value
-      def value_block
-        return @value_block if instance_variable_defined?(:@value_block)
-
-        @value_block =
-          block ||
-          opts[:value] ||
-          const_block ||
-          delegate_block ||
-          keyword_block
+        @serializer = ser.is_a?(String) ? Object.const_get(ser, false) : ser.call
       end
 
       #
@@ -135,46 +99,14 @@ class Serega
 
       private
 
-      def const_block
-        return unless opts.key?(:const)
-
-        const = opts[:const]
-        proc { const }
-      end
-
-      def keyword_block
-        key_method_name = key
-        proc do |object|
-          handle_no_method_error { object.public_send(key_method_name) }
-        end
-      end
-
-      def delegate_block
-        delegate = opts[:delegate]
-        return unless delegate
-
-        key_method_name = delegate[:key] || key
-        delegate_to = delegate[:to]
-
-        if delegate[:allow_nil]
-          proc do |object|
-            handle_no_method_error do
-              object.public_send(delegate_to)&.public_send(key_method_name)
-            end
-          end
-        else
-          proc do |object|
-            handle_no_method_error do
-              object.public_send(delegate_to).public_send(key_method_name)
-            end
-          end
-        end
-      end
+      attr_reader :value_block
 
-      def handle_no_method_error
-        yield
-      rescue NoMethodError => error
-        raise error, "NoMethodError when serializing '#{name}' attribute in #{self.class.serializer_class}\n\n#{error.message}", error.backtrace
+      def set_normalized_vars(normalizer)
+        @name = normalizer.name
+        @value_block = normalizer.value_block
+        @hide = normalizer.hide
+        @many = normalizer.many
+        @serializer = normalizer.serializer
       end
     end
 

data/lib/serega/attribute_normalizer.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Prepares provided attribute options
+  #
+  class SeregaAttributeNormalizer
+    #
+    # AttributeNormalizer instance methods
+    #
+    module AttributeNormalizerInstanceMethods
+      # Attribute initial params
+      # @return [Hash] Attribute initial params
+      attr_reader :init_name, :init_opts, :init_block
+
+      #
+      # Instantiates attribute options normalizer
+      #
+      # @param initials [Hash] new attribute options
+      #
+      # @return [SeregaAttributeNormalizer] Instantiated attribute options normalizer
+      #
+      def initialize(initials)
+        @init_name = initials[:name]
+        @init_opts = initials[:opts]
+        @init_block = initials[:block]
+      end
+
+      #
+      # Symbolized initial attribute name
+      #
+      # @return [Symbol] Attribute normalized name
+      #
+      def name
+        @name ||= prepare_name
+      end
+
+      #
+      # Symbolized initial attribute key or attribute name if key is empty
+      #
+      # @return [Symbol] Attribute normalized name
+      #
+      def key
+        @key ||= prepare_key
+      end
+
+      #
+      # Combines all options to return single block that will be used to find
+      # attribute value during serialization
+      #
+      # @return [#call] Attribute normalized callable value block
+      #
+      def value_block
+        @value_block ||= prepare_value_block
+      end
+
+      #
+      # Shows if attribute is specified to be hidden
+      #
+      # @return [Boolean, nil] if attribute must be hidden by default
+      #
+      def hide
+        return @hide if instance_variable_defined?(:@hide)
+
+        @hide = prepare_hide
+      end
+
+      #
+      # Shows if attribute is specified to be a one-to-many relationship
+      #
+      # @return [Boolean, nil] if attribute is specified to be a one-to-many relationship
+      #
+      def many
+        return @many if instance_variable_defined?(:@many)
+
+        @many = prepare_many
+      end
+
+      #
+      # Shows specified attribute serializer
+      # @return [Serega, String, #callable, nil] specified serializer
+      #
+      def serializer
+        return @serializer if instance_variable_defined?(:@serializer)
+
+        @serializer = prepare_serializer
+      end
+
+      private
+
+      def prepare_name
+        init_name.to_sym
+      end
+
+      #
+      # Patched in:
+      # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
+      #
+      def prepare_value_block
+        init_block ||
+          init_opts[:value] ||
+          prepare_const_block ||
+          prepare_delegate_block ||
+          prepare_keyword_block
+      end
+
+      #
+      # Patched in:
+      # - plugin :preloads (returns true by default if config option auto_hide_attribute_with_preloads is enabled)
+      #
+      def prepare_hide
+        init_opts[:hide]
+      end
+
+      def prepare_many
+        init_opts[:many]
+      end
+
+      def prepare_serializer
+        init_opts[:serializer]
+      end
+
+      def prepare_key
+        key = init_opts[:key]
+        key ? key.to_sym : name
+      end
+
+      def prepare_const_block
+        return unless init_opts.key?(:const)
+
+        const = init_opts[:const]
+        proc { const }
+      end
+
+      def prepare_keyword_block
+        key_method_name = key
+        proc do |object|
+          handle_no_method_error { object.public_send(key_method_name) }
+        end
+      end
+
+      def prepare_delegate_block
+        delegate = init_opts[:delegate]
+        return unless delegate
+
+        key_method_name = delegate[:key] || key
+        delegate_to = delegate[:to]
+
+        allow_nil = delegate.fetch(:allow_nil) { self.class.serializer_class.config.delegate_default_allow_nil }
+
+        if allow_nil
+          proc do |object|
+            handle_no_method_error do
+              object.public_send(delegate_to)&.public_send(key_method_name)
+            end
+          end
+        else
+          proc do |object|
+            handle_no_method_error do
+              object.public_send(delegate_to).public_send(key_method_name)
+            end
+          end
+        end
+      end
+
+      def handle_no_method_error
+        yield
+      rescue NoMethodError => error
+        raise error, "NoMethodError when serializing '#{name}' attribute in #{self.class.serializer_class}\n\n#{error.message}", error.backtrace
+      end
+    end
+
+    extend Serega::SeregaHelpers::SerializerClassHelper
+    include AttributeNormalizerInstanceMethods
+  end
+end

data/lib/serega/config.rb

@@ -19,7 +19,8 @@ class Serega
       serialize_keys: %i[context many].freeze,
       check_attribute_name: true,
       check_initiate_params: true,
-      max_cached_map_per_serializer_count: 0,
+      delegate_default_allow_nil: false,
+      max_cached_plans_per_serializer_count: 0,
       to_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
       from_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjLoad : SeregaJSON::JSONLoad
     }.freeze
@@ -87,20 +88,36 @@ class Serega
         opts[:check_initiate_params] = value
       end
 
-      # Returns :max_cached_map_per_serializer_count config option
-      # @return [Boolean] Current :max_cached_map_per_serializer_count config option
-      def max_cached_map_per_serializer_count
-        opts.fetch(:max_cached_map_per_serializer_count)
+      # Returns :delegate_default_allow_nil config option
+      # @return [Boolean] Current :delegate_default_allow_nil config option
+      def delegate_default_allow_nil
+        opts.fetch(:delegate_default_allow_nil)
       end
 
-      # Sets :max_cached_map_per_serializer_count config option
+      # Sets :delegate_default_allow_nil config option
+      #
+      # @param value [Boolean] Set :delegate_default_allow_nil config option
+      #
+      # @return [Boolean] :delegate_default_allow_nil config option
+      def delegate_default_allow_nil=(value)
+        raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
+        opts[:delegate_default_allow_nil] = value
+      end
+
+      # Returns :max_cached_plans_per_serializer_count config option
+      # @return [Boolean] Current :max_cached_plans_per_serializer_count config option
+      def max_cached_plans_per_serializer_count
+        opts.fetch(:max_cached_plans_per_serializer_count)
+      end
+
+      # Sets :max_cached_plans_per_serializer_count config option
       #
       # @param value [Boolean] Set :check_initiate_params config option
       #
-      # @return [Boolean] New :max_cached_map_per_serializer_count config option
-      def max_cached_map_per_serializer_count=(value)
+      # @return [Boolean] New :max_cached_plans_per_serializer_count config option
+      def max_cached_plans_per_serializer_count=(value)
         raise SeregaError, "Must have Integer value, #{value.inspect} provided" unless value.is_a?(Integer)
-        opts[:max_cached_map_per_serializer_count] = value
+        opts[:max_cached_plans_per_serializer_count] = value
       end
 
       # Returns whether attributes names check is disabled

data/lib/serega/object_serializer.rb

@@ -10,16 +10,17 @@ class Serega
     # SeregaObjectSerializer instance methods
     #
     module InstanceMethods
-      attr_reader :context, :points, :many, :opts
+      attr_reader :context, :plan, :many, :opts
 
+      # @param plan [SeregaPlan] Serialization plan
       # @param context [Hash] Serialization context
       # @param many [TrueClass|FalseClass] is object is enumerable
-      # @param points [Array<MapPoint>] Serialization points (attributes)
+      # @param opts [Hash] Any custom options
       #
       # @return [SeregaObjectSerializer] New SeregaObjectSerializer
-      def initialize(context:, points:, many: nil, **opts)
+      def initialize(context:, plan:, many: nil, **opts)
         @context = context
-        @points = points
+        @plan = plan
         @many = many
         @opts = opts
       end
@@ -44,7 +45,7 @@ class Serega
       # Patched in:
       # - plugin :presenter (makes presenter_object and serializes it)
       def serialize_object(object)
-        points.each_with_object({}) do |point, container|
+        plan.points.each_with_object({}) do |point, container|
           serialize_point(object, point, container)
         end
       end
@@ -70,14 +71,14 @@ class Serega
       end
 
       def final_value(value, point)
-        point.has_nested_points? ? relation_value(value, point) : value
+        point.child_plan ? 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)
+        child_plan = point.child_plan
+        child_serializer = point.child_object_serializer
+        child_many = point.many
+        serializer = child_serializer.new(context: context, plan: child_plan, many: child_many, **opts)
         serializer.serialize(value)
       end
 

data/lib/serega/plan.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Constructs plan - list of serialized attributes.
+  # We will traverse this plan to construct serialized response.
+  #
+  class SeregaPlan
+    #
+    # SeregaPlan class methods
+    #
+    module ClassMethods
+      #
+      # Constructs plan of attributes that should be serialized.
+      #
+      # @param opts Serialization parameters
+      # @option opts [Hash] :only The only attributes to serialize
+      # @option opts [Hash] :except Attributes to hide
+      # @option opts [Hash] :with Attributes (usually marked `hide: true`) to serialize additionally
+      #
+      # @return [SeregaPlan] Serialization plan
+      #
+      def call(opts)
+        max_cache_size = serializer_class.config.max_cached_plans_per_serializer_count
+        return plan_for(opts) if max_cache_size.zero?
+
+        cached_plan_for(opts, max_cache_size)
+      end
+
+      private
+
+      def plan_for(opts)
+        new(**modifiers(opts))
+      end
+
+      def cached_plan_for(opts, max_cache_size)
+        @cache ||= {}
+        cache_key = construct_cache_key(opts)
+
+        plan = @cache[cache_key] ||= plan_for(opts)
+        @cache.shift if @cache.length > max_cache_size
+        plan
+      end
+
+      def modifiers(opts)
+        {
+          only: opts[:only] || FROZEN_EMPTY_HASH,
+          except: opts[:except] || FROZEN_EMPTY_HASH,
+          with: opts[:with] || FROZEN_EMPTY_HASH
+        }
+      end
+
+      def construct_cache_key(opts, cache_key = nil)
+        return nil if opts.empty?
+
+        cache_key ||= +""
+
+        opts.each do |key, nested_opts|
+          cache_key.insert(-1, SeregaUtils::SymbolName.call(key))
+          cache_key.insert(-1, "-")
+          construct_cache_key(nested_opts, cache_key)
+        end
+
+        cache_key
+      end
+    end
+
+    #
+    # SeregaPlan instance methods
+    #
+    module InstanceMethods
+      # Parent plan point, if exists
+      # @return [SeregaPlanPoint, nil]
+      attr_reader :parent_plan_point
+
+      # Serialization points
+      # @return [Array<SeregaPlanPoint>] points to serialize
+      attr_reader :points
+
+      #
+      # Instantiate new serialization plan.
+      #
+      # @param opts Serialization parameters
+      # @option opts [Hash] :only The only attributes to serialize
+      # @option opts [Hash] :except Attributes to hide
+      # @option opts [Hash] :with Attributes (usually marked hide: true`) to serialize additionally
+      # @option opts [Hash] :with Attributes (usually marked hide: true`) to serialize additionally
+      #
+      # @return [SeregaPlan] Serialization plan
+      #
+      def initialize(only:, except:, with:, parent_plan_point: nil)
+        @parent_plan_point = parent_plan_point
+        @points = attributes_points(only: only, except: except, with: with)
+      end
+
+      #
+      # Serializer class of current plan
+      #
+      def serializer_class
+        self.class.serializer_class
+      end
+
+      private
+
+      def attributes_points(only:, except:, with:)
+        points = []
+
+        serializer_class.attributes.each_value do |attribute|
+          next unless attribute.visible?(only: only, except: except, with: with)
+
+          child_fields =
+            if attribute.relation?
+              name = attribute.name
+              {only: only[name], with: with[name], except: except[name]}
+            end
+
+          points << serializer_class::SeregaPlanPoint.new(attribute, self, child_fields)
+        end
+
+        points.freeze
+      end
+    end
+
+    extend ClassMethods
+    include InstanceMethods
+    extend SeregaHelpers::SerializerClassHelper
+  end
+end

data/lib/serega/plan_point.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Combines attribute and nested attributes
+  #
+  class SeregaPlanPoint
+    #
+    # SeregaPlanPoint instance methods
+    #
+    module InstanceMethods
+      extend Forwardable
+
+      # Link to current plan this point belongs to
+      # @return [SeregaAttribute] Current plan
+      attr_reader :plan
+
+      # Shows current attribute
+      # @return [SeregaAttribute] Current attribute
+      attr_reader :attribute
+
+      # Shows child plan if exists
+      # @return [SeregaPlan, nil] Attribute serialization plan
+      attr_reader :child_plan
+
+      # Child fields to serialize
+      # @return [SeregaPlan, nil] Attribute serialization plan
+      attr_reader :child_fields
+
+      # @!method name
+      #   Attribute `name`
+      #   @see SeregaAttribute::AttributeInstanceMethods#name
+      # @!method value
+      #   Attribute `value` block
+      #   @see SeregaAttribute::AttributeInstanceMethods#value
+      # @!method many
+      #   Attribute `many` option
+      #   @see SeregaAttribute::AttributeInstanceMethods#many
+      # @!method serializer
+      #   Attribute `serializer` option
+      #   @see SeregaAttribute::AttributeInstanceMethods#serializer
+      def_delegators :@attribute, :name, :value, :many, :serializer
+
+      #
+      # Initializes plan point
+      #
+      # @param plan [SeregaPlan] Plan where this point belongs to.
+      # @param attribute [SeregaAttribute] Attribute to construct plan point
+      # @param child_fields [Hash, nil] Child fields (:only, :with, :except)
+      #
+      # @return [SeregaPlanPoint] New plan point
+      #
+      def initialize(attribute, plan = nil, child_fields = nil)
+        @plan = plan
+        @attribute = attribute
+        @child_fields = child_fields
+        set_normalized_vars
+        freeze
+      end
+
+      #
+      # @return [SeregaObjectSerializer] object serializer for child plan
+      #
+      def child_object_serializer
+        serializer::SeregaObjectSerializer
+      end
+
+      private
+
+      # Patched in:
+      # - plugin :batch (prepares @batch)
+      # - plugin :preloads (prepares @preloads and @preloads_path)
+      def set_normalized_vars
+        @child_plan = prepare_child_plan
+      end
+
+      def prepare_child_plan
+        return unless serializer
+
+        fields = child_fields || FROZEN_EMPTY_HASH
+
+        serializer::SeregaPlan.new(
+          parent_plan_point: self,
+          only: fields[:only] || FROZEN_EMPTY_HASH,
+          with: fields[:with] || FROZEN_EMPTY_HASH,
+          except: fields[:except] || FROZEN_EMPTY_HASH
+        )
+      end
+    end
+
+    extend SeregaHelpers::SerializerClassHelper
+    include InstanceMethods
+  end
+end