serega 0.42.0 → 0.50.0

data/VERSION

@@ -1 +1 @@
-0.42.0
+0.50.0

data/lib/serega/attribute.rb

@@ -4,148 +4,203 @@ class Serega
   #
   # Stores serialized attribute data
   #
-  # @private
-  class SeregaAttribute
-    #
-    # Attribute instance methods
+  class SeregaAttribute # :nodoc:
+    # Serializer of the attribute
+    attr_reader :serializer_class
+
+    # Attribute initial params
+    attr_reader :initials
+
+    # Attribute name
+    attr_reader :name
+
+    # Where the attribute is defined
+    def location
+      initials[:location]
+    end
+
+    # Attribute :many option
+    attr_reader :many
+
+    # Attribute :default option
+    attr_reader :default
+
+    # Attribute :hide option
+    attr_reader :hide
+
+    # Attribute :preloads option
+    attr_reader :preloads
+
+    # Batch loader names required to detect attribute value
+    attr_reader :batch_loaders
+
+    # Batch loader given directly as the :batch option
+    attr_reader :inline_batch_loader
+
+    # Attribute :if, :unless, :if_value and :unless_value conditions
+    attr_reader :conditions
+
+    # Initializes new attribute
+    def initialize(serializer_class, name:, opts: {}, block: nil, location: nil)
+      SeregaValidations::CheckAttributeParams.new(serializer_class, name, opts, block).validate
+
+      @serializer_class = serializer_class
+      @initials = SeregaUtils::EnumDeepFreeze.call(
+        name: name,
+        opts: SeregaUtils::EnumDeepDup.call(opts),
+        block: block,
+        location: location
+      )
+
+      normalizer = SeregaAttributeNormalizer.new(serializer_class, initials)
+      set_normalized_vars(normalizer)
+      @value_method = define_value_method(serializer_class)
+    end
+
+    # Method of the serialized object that gives the value, `nil` for a value
+    # from :value, :const, :delegate, :hash_access or :batch
+    def object_method
+      @value_block.keyword if @value_block.is_a?(AttributeValueResolvers::Keyword)
+    end
+
+    # Name of the SeregaAttributeValues method that reads the value
+    attr_reader :value_method
+
+    # Whether the attribute has an :if, :unless, :if_value or :unless_value condition
+    def conditional?
+      !@conditions.nil?
+    end
+
+    # Shows whether attribute has specified serializer
+    def relation?
+      !@serializer.nil?
+    end
+
+    # Shows specified serializer class. A frozen attribute resolves its
+    # String or Proc serializer on each call.
+    def serializer
+      serializer = @serializer
+      return serializer if (serializer.is_a?(Class) && (serializer < Serega)) || !serializer
+
+      serializer = serializer.is_a?(String) ? Object.const_get(serializer, false) : serializer.call
+      frozen? ? serializer : (@serializer = serializer)
+    end
+
+    # Finds attribute value
     #
-    # @private
-    module AttributeInstanceMethods
-      # Attribute initial params
-      # @return [Hash] Attribute initial params
-      attr_reader :initials
-
-      # Attribute name
-      # @return [Symbol] Attribute name
-      attr_reader :name
-
-      # Attribute :many option
-      # @return [Boolean, nil] Attribute :many option
-      attr_reader :many
-
-      # Attribute :default option
-      # @return [Object, nil] Attribute :default option
-      attr_reader :default
-
-      # Attribute :hide option
-      # @return [Boolean, nil] Attribute :hide option
-      attr_reader :hide
-
-      # Attribute :preloads option
-      # @return [Hash, nil] Attribute :preloads option
-      attr_reader :preloads
-
-      # Batch loader names required to detect attribute value
-      # @return [Array<Symbol>] Batch loader names
-      attr_reader :batch_loaders
-
-      #
-      # Initializes new attribute
-      #
-      # @param name [Symbol, String] Name of attribute
-      # @param opts [Hash] Attribute options
-      # @option opts [Symbol] :method 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) && !object.is_a?(Hash) && !object.is_a?(Struct)
-      # @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] Defines attributes of a nested anonymous serializer
-      #
-      def initialize(name:, opts: {}, block: nil)
-        serializer_class = self.class.serializer_class
-        serializer_class::CheckAttributeParams.new(name, opts, block).validate
-
-        @initials = SeregaUtils::EnumDeepFreeze.call(
-          name: name,
-          opts: SeregaUtils::EnumDeepDup.call(opts),
-          block: block
-        )
-
-        normalizer = serializer_class::SeregaAttributeNormalizer.new(initials)
-        set_normalized_vars(normalizer)
-      end
+    # Generated code reads plain attributes without this method, with
+    # their #value_code.
+    def value(object, context, batches: nil)
+      # Signatures should match allowed signatures in CheckOptValue
+      result =
+        case @value_block_signature
+        when "1" then @value_block.call(object)
+        when "1_ctx" then @value_block.call(object, ctx: context)
+        when "1_batches" then @value_block.call(object, batches: batches)
+        when "1_batches_ctx" then @value_block.call(object, ctx: context, batches: batches)
+        when "2" then @value_block.call(object, context)
+        when "2_batches_ctx" then @value_block.call(object, context, ctx: context, batches: batches)
+        else @value_block.call # signature is "0" - no parameters
+        end
+
+      result = @default if result.nil?
+      @formatter ? @formatter.call(result, context) : result
+    end
 
-      # Shows whether attribute has specified serializer
-      # @return [Boolean] Checks if attribute is relationship (if :serializer option exists)
-      def relation?
-        !@serializer.nil?
-      end
+    # Ruby code that reads the attribute value of the source. `:const` and
+    # `:default` values and formatters come from the `CONSTANTS`,
+    # `DEFAULTS`, `FORMATTERS` and `FORMATTER_ARGS` of SeregaAttributeValues.
+    def value_code(source_variable, constants_prefix = "")
+      code =
+        case @value_block
+        when AttributeValueResolvers::Keyword,
+             AttributeValueResolvers::Delegate,
+             AttributeValueResolvers::DelegateAllowNil,
+             AttributeValueResolvers::HashAccessKeyword,
+             AttributeValueResolvers::HashAccessDelegate,
+             AttributeValueResolvers::HashAccessDelegateAllowNil
+          @value_block.code(source_variable)
+        when AttributeValueResolvers::Const
+          "#{constants_prefix}CONSTANTS[#{name.inspect}]"
+        end
+      return unless code
+
+      code = "(value = #{code}).nil? ? #{constants_prefix}DEFAULTS[#{name.inspect}] : value" unless @default.nil?
+      return code unless @formatter
+
+      @formatter.code(code, "#{constants_prefix}FORMATTERS[#{name.inspect}]", "#{constants_prefix}FORMATTER_ARGS[#{name.inspect}]")
+    end
 
-      # Shows specified serializer class
-      # @return [Serega, nil] Attribute serializer if exists
-      def serializer
-        serializer = @serializer
-        return serializer if (serializer.is_a?(Class) && (serializer < Serega)) || !serializer
+    # Checks if attribute must be added to serialized response
+    def visible?(only, except, with, only_limits)
+      return false if except.member?(name) && except[name].empty?
+      return true if only.member?(name) || with.member?(name)
+      return false if only_limits
 
-        @serializer = serializer.is_a?(String) ? Object.const_get(serializer, false) : serializer.call
-      end
+      !hide
+    end
 
-      #
-      # Finds attribute value
-      #
-      # @param object [Object] Serialized object
-      # @param context [Hash, nil] Serialization context
-      #
-      # @return [Object] Serialized attribute value
-      #
-      def value(object, context, batches: nil)
-        # Signatures should match allowed signatures in CheckOptValue
-        result =
-          case value_block_signature
-          when "1" then value_block.call(object)
-          when "1_ctx" then value_block.call(object, ctx: context)
-          when "1_batches" then value_block.call(object, batches: batches)
-          when "1_batches_ctx" then value_block.call(object, ctx: context, batches: batches)
-          when "2" then value_block.call(object, context)
-          when "2_batches_ctx" then value_block.call(object, context, ctx: context, batches: batches)
-          else value_block.call # signature is "0" - no parameters
-          end
-
-        result.nil? ? default : result
-      end
+    # Defines the methods of the code on the owner, at the file and line of
+    # the attribute, thus their backtraces point to the attribute
+    def define_methods(owner, code)
+      file, _, line = location ? location.rpartition(":") : ["(attribute #{name})", nil, "1"]
+      owner.class_eval(code, file, line.to_i)
+    end
 
-      #
-      # Checks if attribute must be added to serialized response
-      #
-      # @param modifiers [Hash] Serialization modifiers
-      # @option modifiers [Hash] :only The only attributes to serialize
-      # @option modifiers [Hash] :except Attributes to hide
-      # @option modifiers [Hash] :with Hidden attributes to serialize additionally
-      #
-      # @return [Boolean]
-      #
-      def visible?(modifiers)
-        except = modifiers[:except] || FROZEN_EMPTY_HASH
-        only = modifiers[:only] || FROZEN_EMPTY_HASH
-        with = modifiers[:with] || FROZEN_EMPTY_HASH
-
-        return false if except.member?(name) && except[name].empty?
-        return true if only.member?(name)
-        return true if with.member?(name)
-        return false unless only.empty?
-
-        !hide
-      end
+    private
+
+    # Defines the SeregaAttributeValues method that reads the value of a
+    # source directly, for example `read_full_name`. The method has the
+    # file and line of the attribute.
+    def define_value_method(serializer_class)
+      code = value_code("source")
+      return unless code
 
-      private
+      values_class = serializer_class::SeregaAttributeValues
+      values_class::CONSTANTS[name] = @value_block.call if @value_block.is_a?(AttributeValueResolvers::Const)
+      values_class::DEFAULTS[name] = @default unless @default.nil?
+      values_class::FORMATTERS[name] = @formatter.callable if @formatter&.callable
+      values_class::FORMATTER_ARGS[name] = @formatter.args if @formatter&.args
 
-      attr_reader :value_block, :value_block_signature
+      method_name = value_method_name(values_class)
+      define_methods(values_class, "def #{method_name}(source) = #{code}")
+      method_name
+    end
 
-      def set_normalized_vars(normalizer)
-        @name = normalizer.name
-        @many = normalizer.many
-        @default = normalizer.default
-        @value_block = normalizer.value_block
-        @value_block_signature = normalizer.value_block_signature
-        @hide = normalizer.hide
-        @serializer = normalizer.serializer
-        @preloads = normalizer.preloads
-        @batch_loaders = normalizer.batch_loaders
+    # Plain method name of the attribute, for example `read_first_name` for
+    # `first-name`. The name keeps a final `?` or `!`. A name taken by
+    # another attribute gets a number, for example `read_first_name_2`. The
+    # same attribute keeps its name.
+    def value_method_name(values_class)
+      method_names = values_class::METHOD_NAMES
+      method_name = method_names[name]
+      return method_name if method_name
+
+      base, mark = name.to_s.match(/\A(.*?)([?!]?)\z/).captures
+      base = "read_#{base.gsub(/\W/, "_")}"
+      method_name = :"#{base}#{mark}"
+      number = 1
+      while method_names.value?(method_name)
+        number += 1
+        method_name = :"#{base}_#{number}#{mark}"
       end
+      method_names[name] = method_name
     end
 
-    extend Serega::SeregaHelpers::SerializerClassHelper
-    include AttributeInstanceMethods
+    def set_normalized_vars(normalizer)
+      @name = normalizer.name
+      @many = normalizer.many
+      @default = normalizer.default
+      @value_block = normalizer.value_block
+      @value_block_signature = normalizer.value_block_signature
+      @hide = normalizer.hide
+      @serializer = normalizer.serializer
+      @preloads = normalizer.preloads
+      @batch_loaders = normalizer.batch_loaders
+      @inline_batch_loader = normalizer.inline_batch_loader
+      @formatter = normalizer.formatter
+      conditions = normalizer.conditions
+      @conditions = conditions && SeregaConditions.new(self, conditions)
+    end
   end
 end