serega 0.41.0 → 0.50.0

data/lib/serega/plugins/presenter/presenter.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-require "delegate"
-require "forwardable"
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin :presenter — moves computed attribute logic into a dedicated Presenter class.
-    #
-    # Presenter inherits from SimpleDelegator:
-    # - All methods of the serialized object are available directly inside presenter methods.
-    # - Methods not defined on Presenter are resolved via method_missing on the first call
-    #   and then defined as real delegators, so subsequent calls skip method_missing entirely.
-    # - The original object is accessible via __getobj__ (standard SimpleDelegator API).
-    # - The serialization context is accessible via the private method __ctx__.
-    #
-    # The `presenter do ... end` block is evaluated inside the serializer's own
-    # Presenter class, so multiple blocks accumulate.
-    #
-    # @example
-    #   class UserSerializer < Serega
-    #     plugin :presenter
-    #
-    #     attribute :name
-    #     attribute :role
-    #
-    #     presenter do
-    #       def name
-    #         [first_name, last_name].compact.join(' ') # first_name/last_name delegated to object
-    #       end
-    #
-    #       def role
-    #         id == __ctx__[:current_user_id] ? :self : :other
-    #       end
-    #     end
-    #   end
-    #
-    module Presenter
-      # @return [Symbol] Plugin name
-      # @private
-      def self.plugin_name
-        :presenter
-      end
-
-      #
-      # Applies plugin code to specific serializer
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param _opts [Hash] Plugin options
-      #
-      # @return [void]
-      #
-      # @private
-      def self.load_plugin(serializer_class, **_opts)
-        serializer_class.extend(ClassMethods)
-        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]
-      #
-      # @private
-      def self.after_load_plugin(serializer_class, **_opts)
-        presenter_class = Class.new(Presenter)
-        presenter_class.serializer_class = serializer_class
-        serializer_class.const_set(:Presenter, presenter_class)
-
-        # The presenter's unwrap method returns the serialized object itself,
-        # not an association — it must never be auto-preloaded.
-        config = serializer_class.config
-        config.auto_preload_excluded_methods = config.auto_preload_excluded_methods | [:__getobj__]
-      end
-
-      # Presenter class
-      # @private
-      class Presenter < SimpleDelegator
-        # Presenter instance methods
-        # @private
-        module InstanceMethods
-          #
-          # @param object [Object] Serialized object to wrap
-          # @param ctx [Hash, nil] Serialization context
-          #
-          def initialize(object, ctx = nil)
-            super(object)
-            @__ctx__ = ctx
-          end
-
-          private
-
-          attr_reader :__ctx__
-
-          #
-          # Delegates all missing methods to serialized object.
-          #
-          # Creates delegator method after first #method_missing hit to improve
-          # performance of following serializations.
-          #
-          def method_missing(name, *_args, &_block) # rubocop:disable Style/MissingRespondToMissing -- base SimpleDelegator class has this method
-            super.tap do
-              self.class.def_delegator :__getobj__, name
-            end
-          end
-        end
-
-        extend SeregaHelpers::SerializerClassHelper
-        extend Forwardable
-        include InstanceMethods
-
-        # Tracks whether user code was added to the Presenter class.
-        #
-        # These singleton methods are defined after the base class body above,
-        # so the plugin's own includes do not mark the base class as modified.
-        # Lazy delegators defined by #method_missing do mark the class, but
-        # they can appear only on presenters that are already wrapping.
-        class << self
-          #
-          # Checks if this Presenter class (or an inherited one) was extended
-          # with custom user code and therefore objects must be wrapped
-          #
-          # @return [Boolean] whether custom presenter methods were defined
-          #
-          def modified?
-            return true if defined?(@modified)
-            return false if equal?(Presenter) # the plugin's base class — the walk stops here
-
-            superclass.modified?
-          end
-
-          # Marks the class as modified, then includes the module
-          # @return [void]
-          def include(*modules)
-            @modified = true
-            super
-          end
-
-          # Marks the class as modified, then prepends the module
-          # @return [void]
-          def prepend(*modules)
-            @modified = true
-            super
-          end
-
-          private
-
-          def method_added(name)
-            @modified = true
-            super
-          end
-        end
-      end
-
-      #
-      # Serega additional/patched class methods
-      #
-      # @see Serega
-      #
-      module ClassMethods
-        #
-        # Defines presenter methods — evaluates the block inside the
-        # serializer's own Presenter class. Multiple blocks accumulate.
-        #
-        #   presenter do
-        #     def name
-        #       [first_name, last_name].compact.join(" ")
-        #     end
-        #   end
-        #
-        # @return [void]
-        #
-        def presenter(&block)
-          raise SeregaError, "Provide a block with presenter methods: `presenter do ... end`" unless block
-
-          self::Presenter.class_exec(&block)
-          nil
-        end
-
-        #
-        # Checks if the serializer's Presenter class (or an inherited one) was
-        # extended with custom user code. When it was not, serialized objects
-        # are not wrapped in the Presenter at all.
-        #
-        # @return [Boolean] whether custom presenter methods were defined
-        #
-        # @private
-        def custom_presenter?
-          self::Presenter.modified?
-        end
-
-        private
-
-        def inherited(subclass)
-          super
-
-          presenter_class = Class.new(self::Presenter)
-          presenter_class.serializer_class = subclass
-          subclass.const_set(:Presenter, presenter_class)
-        end
-      end
-
-      #
-      # SeregaObjectSerializer additional/patched class methods
-      #
-      # @see Serega::SeregaObjectSerializer
-      #
-      # @private
-      module SeregaObjectSerializerInstanceMethods
-        # The custom-presenter check is made once per object serializer here
-        # and its result is reused for every enqueued chunk of the level.
-        def initialize(**opts)
-          super
-          @wrap_in_presenter = self.class.serializer_class.custom_presenter?
-        end
-
-        private
-
-        #
-        # Wraps each serialized object in Presenter.new(object, ctx) before it is
-        # enqueued, so the whole level — value resolution and batch loaders alike —
-        # sees presenters. Objects are not wrapped when the Presenter class has
-        # no custom methods — such wrapping would only add overhead and break
-        # class checks (object.is_a?, Hash === object) without changing anything.
-        #
-        def enqueue(objects)
-          return super unless @wrap_in_presenter
-
-          presenter = self.class.serializer_class::Presenter
-          presenters = objects.map { |object| presenter.new(object, context) }
-          super(presenters)
-        end
-      end
-    end
-
-    register_plugin(Presenter.plugin_name, Presenter)
-  end
-end

data/lib/serega/plugins/string_modifiers/parse_string_modifiers.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin :string_modifiers
-    #
-    # Allows to specify modifiers as strings.
-    #
-    # Serialized attributes must be split with `,` and nested attributes can be defined inside brackets `(`, `)`.
-    #
-    # @example
-    #   PostSerializer.plugin :string_modifiers
-    #   PostSerializer.new(only: "id,user(id,username)").to_h(post)
-    #   PostSerializer.new(except: "user(username,email)").to_h(post)
-    #   PostSerializer.new(with: "user(email)").to_h(post)
-    #
-    #   # Modifiers can still be provided old way with nested hashes or arrays.
-    #   PostSerializer.new(with: {user: %i[email, username]}).to_h(post)
-    #
-    module StringModifiers
-      #
-      # Modifiers parser
-      #
-      # @private
-      class ParseStringModifiers
-        COMMA = ","
-        COMMA_CODEPOINT = COMMA.ord
-        LPAREN = "("
-        LPAREN_CODEPOINT = LPAREN.ord
-        RPAREN = ")"
-        RPAREN_CODEPOINT = RPAREN.ord
-        private_constant :COMMA, :LPAREN, :RPAREN, :COMMA_CODEPOINT, :LPAREN_CODEPOINT, :RPAREN_CODEPOINT
-
-        class << self
-          #
-          # Parses string modifiers
-          #
-          # @param fields [String]
-          #
-          # @return [Hash] parsed modifiers in form of nested hash
-          #
-          # @example
-          #   parse("user") => { user: {} }
-          #   parse("user(id)") => { user: { id: {} } }
-          #   parse("user(id,name)") => { user: { id: {}, name: {} } }
-          #   parse("user,comments") => { user: {}, comments: {} }
-          #   parse("user(comments(text))") => { user: { comments: { text: {} } } }
-          def parse(fields)
-            result = {}
-            attribute_storage = result
-            path_stack = (fields.include?(LPAREN) || fields.include?(RPAREN)) ? [] : nil
-
-            start_index = 0
-            end_index = 0
-            fields.each_codepoint do |codepoint|
-              case codepoint
-              when COMMA_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-                start_index = end_index + 1
-              when LPAREN_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                if attribute
-                  attribute_storage = add_attribute(attribute_storage, attribute, {})
-                  path_stack.push(attribute)
-                end
-                start_index = end_index + 1
-              when RPAREN_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-                path_stack.pop
-                attribute_storage = dig?(result, path_stack)
-                start_index = end_index + 1
-              end
-
-              end_index += 1
-            end
-
-            attribute = extract_attribute(fields, start_index, end_index)
-            add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-
-            result
-          end
-
-          private
-
-          def extract_attribute(fields, start_index, end_index)
-            attribute = fields[start_index, end_index - start_index]
-            attribute.strip!
-            attribute.empty? ? nil : attribute.to_sym
-          end
-
-          def add_attribute(storage, attribute, nested_attributes = FROZEN_EMPTY_HASH)
-            storage[attribute] = nested_attributes
-          end
-
-          def dig?(hash, path)
-            return hash if !path || path.empty?
-
-            path.each do |point|
-              hash = hash[point]
-            end
-
-            hash
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/plugins/string_modifiers/string_modifiers.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin :string_modifiers
-    #
-    # Allows `:only`, `:except` and `:with` to be given as a single comma-separated
-    # string, with nested attributes in parentheses. Useful for accepting a field
-    # list straight from a query parameter.
-    #
-    # @example
-    #   class UserSerializer < Serega
-    #     plugin :string_modifiers
-    #
-    #     attribute :username
-    #     attribute :first_name
-    #     attribute :addresses, serializer: AddressSerializer, hide: true
-    #   end
-    #
-    #   UserSerializer.to_h(user, only: "username,addresses(line1,line2)")
-    #
-    module StringModifiers
-      # @return [Symbol] Plugin name
-      # @private
-      def self.plugin_name
-        :string_modifiers
-      end
-
-      #
-      # Applies plugin code to specific serializer
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param _opts [Hash] Plugin options
-      #
-      # @return [void]
-      #
-      # @private
-      def self.load_plugin(serializer_class, **_opts)
-        serializer_class.include(InstanceMethods)
-        require_relative "parse_string_modifiers"
-      end
-
-      #
-      # Serega additional/patched instance methods
-      #
-      # @see Serega
-      #
-      # @private
-      module InstanceMethods
-        private
-
-        def parse_modifier(value)
-          return ParseStringModifiers.parse(value) if value.is_a?(String)
-
-          super
-        end
-      end
-    end
-
-    register_plugin(StringModifiers.plugin_name, StringModifiers)
-  end
-end

data/lib/serega/utils/symbol_name.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  # @private
-  module SeregaUtils
-    #
-    # Utility to get frozen string from symbol in any ruby version
-    #
-    # @private
-    class SymbolName
-      class << self
-        #
-        # Returns frozen string corresponding to provided symbol
-        #
-        # @param key [Symbol]
-        #
-        # @return [String] frozen string corresponding to provided symbol
-        #
-        def call(key)
-          key.is_a?(String) ? key : to_frozen_string(key)
-        end
-
-        private
-
-        # :nocov:
-        if RUBY_VERSION < "3"
-          def to_frozen_string(key)
-            key.to_s.freeze
-          end
-        else
-          def to_frozen_string(key)
-            key.name
-          end
-        end
-        # :nocov:
-      end
-    end
-  end
-end

data/lib/serega/validations/attribute/check_opt_const.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
-      #
-      # Attribute `:const` option validator
-      #
-      # @private
-      class CheckOptConst
-        class << self
-          #
-          # Checks attribute :const option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] Attribute validation error
-          #
-          # @return [void]
-          #
-          def call(opts)
-            return unless opts.key?(:const)
-
-            check_usage_with_other_params(opts)
-          end
-
-          private
-
-          def check_usage_with_other_params(opts)
-            raise SeregaError, "Option :const can not be used together with option :method" if opts.key?(:method)
-            raise SeregaError, "Option :const can not be used together with option :value" if opts.key?(:value)
-            raise SeregaError, "Option :const can not be used together with option :batch" if opts.key?(:batch)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/validations/check_initiate_params.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  # @private
-  module SeregaValidations
-    #
-    # Validations of serializer initialization options
-    #
-    # @private
-    class CheckInitiateParams
-      #
-      # Validations of serializer initialization options instance methods
-      #
-      # @private
-      module InstanceMethods
-        # @return [Hash] validated initialization options
-        attr_reader :opts
-
-        #
-        # Initializes validator for initialization options
-        #
-        # @param opts [Hash] initialization options
-        #
-        # @return [void]
-        #
-        def initialize(opts)
-          @opts = opts
-        end
-
-        #
-        # Validates initiating params
-        #
-        def validate
-          check_allowed_keys
-          check_modifiers
-        end
-
-        private
-
-        def check_allowed_keys
-          Utils::CheckAllowedKeys.call(opts, serializer_class.config.initiate_keys, :initiate)
-        end
-
-        def check_modifiers
-          Initiate::CheckModifiers.new.call(serializer_class, opts[:only], opts[:with], opts[:except])
-        end
-
-        def serializer_class
-          self.class.serializer_class
-        end
-      end
-
-      include InstanceMethods
-      extend Serega::SeregaHelpers::SerializerClassHelper
-    end
-  end
-end

data/lib/serega/validations/check_serialize_params.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  # @private
-  module SeregaValidations
-    #
-    # Validations of serialization options
-    #
-    # @private
-    class CheckSerializeParams
-      #
-      # Validations of serialization options instance methods
-      #
-      # @private
-      module InstanceMethods
-        attr_reader :opts
-
-        #
-        # Initializes validator for serialization options
-        #
-        # @param opts [Hash] serialization options
-        #
-        # @return [void]
-        #
-        def initialize(opts)
-          @opts = opts
-        end
-
-        #
-        # Validates serialization options
-        #
-        def validate
-          check_opts
-        end
-
-        private
-
-        def check_opts
-          Utils::CheckAllowedKeys.call(opts, serializer_class.config.serialize_keys, :serialize)
-
-          Utils::CheckOptIsHash.call(opts, :context)
-          Utils::CheckOptIsBool.call(opts, :many)
-        end
-
-        def serializer_class
-          self.class.serializer_class
-        end
-      end
-
-      include InstanceMethods
-      extend Serega::SeregaHelpers::SerializerClassHelper
-    end
-  end
-end