serega 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d54f033e70155c517c02d15cd9a4eb5399e385b0ffdd68d8c6c2b390201a007
-  data.tar.gz: 23257bef39a343bea74c063f452fa1feed58738c454e467838cceb2fecdbe862
+  metadata.gz: 4ec97ed9e6fc97612c5094991de19b1c5d43a44168e5a29593bdf75f77e5f200
+  data.tar.gz: 54d42defad67c2ea46bac516870caacb36ce38643826137900b46a8661001cc3
 SHA512:
-  metadata.gz: 2a0df718af2b8f019af2fe9dc8bb82dc21a03631a211ecc00a3fd4e83d6ed3324505727c9124975181869fd11fb452e7670a060ae7e04eddd161186e3353366f
-  data.tar.gz: e5bc125a847e929bdaeb7ce044adbb4e866324d702032ee19abd76208949f406b166f4ecf111453d0f7130aa3dfb7d36e3269010df8adc7e05c50eba3c3a52cd
+  metadata.gz: 5c9f5c91fc97ae0b08578b6fb7c98c3718194094af81fb6175cd3854f602b8daa450204cd75b054cd9ee62586aed08f120b32d209a4817fb5bfdb74c6b83bd55
+  data.tar.gz: bd05febbd13a095a4e00f0336514c540c0781eac2707e29e8d9c64e6b4bc0152a7b717e05b93bfdca969e01b1fed4eeeeb52a330b3e9c7a820986b0b30e5b9e0

data/README.md

@@ -20,7 +20,7 @@ It has some great features:
 - Solutions for N+1 problem (via built-in [batch loading](#batch-loading), [preloads][preloads] or
   [activerecord_preloads][activerecord_preloads] plugin)
 - Load serialized objects by ids ([prepare_initial_objects](#prepare-initial-objects))
-- Built-in object presenter ([presenter][presenter] plugin)
+- Built-in object presenter ([presenter][presenter])
 - Adding custom metadata (via [metadata][metadata] or
   [context_metadata][context_metadata] plugins)
 - Value formatters ([formatters][formatters] plugin) helps to transform
@@ -49,13 +49,13 @@ It has some great features:
    - [Serializing the same object in association](#serializing-the-same-object-in-association)
    - [Custom preloading](#custom-preloading)
 - [Serializing Hash records](#serializing-hash-records)
+- [Presenter](#presenter)
 - [Plugins](#plugins)
    - [Plugin :activerecord_preloads](#plugin-activerecord_preloads)
    - [Plugin :root](#plugin-root)
    - [Plugin :metadata](#plugin-metadata)
    - [Plugin :context_metadata](#plugin-context_metadata)
    - [Plugin :formatters](#plugin-formatters)
-   - [Plugin :presenter](#plugin-presenter)
    - [Plugin :string_modifiers](#plugin-string_modifiers)
    - [Plugin :if](#plugin-if)
    - [Plugin :camel_case](#plugin-camel_case)
@@ -128,8 +128,8 @@ class UserSerializer < Serega
   config.base_serializer = Serega
 
   # Method :itself is handy to serialize the same object with a nested set of
-  # attributes. Note: with the :presenter plugin the serialized value will be
-  # the Presenter instance itself; use `method: :__getobj__` to serialize the
+  # attributes. Note: with a custom presenter the serialized value will be
+  # the presenter instance itself; use `method: :__getobj__` to serialize the
   # original unwrapped object instead.
   attribute :statistics, method: :itself do
     attribute :likes_count
@@ -849,6 +849,62 @@ attribute :city,
   }
 ```
 
+## Presenter
+
+Moves computed attribute logic out of `:value` blocks and into a
+`presenter do ... end` block, keeping serializers readable as schemas rather
+than bags of lambdas.
+
+Computed attributes can be written as inline blocks:
+
+```ruby
+class UserSerializer < Serega
+  attribute :name, value: proc { |user| [user.first_name, user.last_name].compact.join(' ') }
+  attribute :role, value: proc { |user, ctx| user.id == ctx[:current_user_id] ? :self : :other }
+end
+```
+
+They can also be written as methods in a `presenter do ... end` block:
+
+```ruby
+class UserSerializer < Serega
+  attribute :name
+  attribute :role
+
+  presenter do
+    def name
+      [first_name, last_name].compact.join(' ')
+    end
+
+    def role
+      id == __ctx__[:current_user_id] ? :self : :other
+    end
+  end
+end
+
+user = OpenStruct.new(id: 1, first_name: 'Bruce', last_name: 'Wayne')
+UserSerializer.to_h(user, context: {current_user_id: 1})
+# => {name: "Bruce Wayne", role: :self}
+```
+
+Multiple `presenter` blocks accumulate. A child serializer runs its parent's
+blocks followed by its own, so it gets the parent's presenter methods while its
+own stay out of the parent. The parent's blocks are copied when the child class
+is created, so a `presenter` block added to a parent afterwards does not reach it.
+
+Presenter methods run on a `SimpleDelegator` wrapping the serialized object, so
+every method of that object is available directly. Any method not defined in a
+`presenter` block is delegated to the object on the first call, and a real
+delegator method is defined for it — so all subsequent serializations call it
+directly.
+
+The wrapped object is accessible via `__getobj__` when you need an unambiguous
+reference to it. The serialization context is accessible via `__ctx__`.
+
+Objects are wrapped only when the serializer has presenter methods. A serializer
+without them costs nothing — its attribute values, batch loaders and value
+callables receive the raw objects.
+
 ## Plugins
 
 ### Plugin :activerecord_preloads
@@ -1049,61 +1105,6 @@ class UserSerializer < Serega
 end
 ```
 
-### Plugin :presenter
-
-Moves computed attribute logic out of blocks and into a dedicated `Presenter` class,
-keeping serializers readable as schemas rather than bags of lambdas.
-
-Without the plugin, computed attributes live as inline blocks:
-
-```ruby
-class UserSerializer < Serega
-  attribute :name, value: proc { |u| [u.first_name, u.last_name].compact.join(' ') }
-  attribute :role, value: proc { |u, ctx| u == ctx[:current_user] ? :self : :other }
-end
-```
-
-With the plugin, they move into a `presenter do ... end` block:
-
-```ruby
-class UserSerializer < Serega
-  plugin :presenter
-
-  attribute :name
-  attribute :role
-
-  presenter do
-    def name
-      [first_name, last_name].compact.join(' ')
-    end
-
-    def role
-      id == __ctx__[:current_user_id] ? :self : :other
-    end
-  end
-end
-```
-
-The block is evaluated inside the serializer's own `Presenter` class, so
-multiple `presenter` blocks accumulate.
-
-`Presenter` inherits from `SimpleDelegator`, so every method of the serialized
-object is available directly inside presenter methods. Any method not explicitly
-defined on `Presenter` is resolved via `method_missing` on the first call, which
-also defines a real delegator method — so all subsequent serializations call it
-directly, without going through `method_missing` again.
-
-The original wrapped object is accessible via `__getobj__` (standard
-`SimpleDelegator` API) when you need an unambiguous reference to it.
-
-The serialization context is accessible via the private method `__ctx__`.
-
-Objects are wrapped in the `Presenter` only when the serializer's `Presenter`
-class (or an inherited one) actually defines custom methods. Loading the
-plugin in a base serializer adds no overhead to serializers that don't
-customize their presenters — their attribute values, batch loaders and value
-callables keep receiving the raw objects.
-
 ### Plugin :string_modifiers
 
 Allows `:only`, `:except` and `:with` to be given as a single comma-separated
@@ -1298,7 +1299,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [hash_access]: #serializing-hash-records
 [metadata]: #plugin-metadata
 [preloads]: #preloads
-[presenter]: #plugin-presenter
+[presenter]: #presenter
 [root]: #plugin-root
 [string_modifiers]: #plugin-string_modifiers
 [if]: #plugin-if

data/VERSION

@@ -1 +1 @@
-0.41.0
+0.42.0

data/lib/serega/config.rb

@@ -33,7 +33,7 @@ class Serega
       delegate_default_allow_nil: false,
       max_cached_plans_per_serializer_count: 0,
       auto_preload: {has_delegate_option: false, has_serializer_option: false},
-      auto_preload_excluded_methods: %i[itself].freeze,
+      auto_preload_excluded_methods: %i[itself __getobj__].freeze,
       hide_by_default: false,
       batch_id_option: :id,
       base_serializer: nil,

data/lib/serega/object_serializer.rb

@@ -16,7 +16,7 @@ class Serega
     #
     # @private
     module InstanceMethods
-      attr_reader :context, :plan, :many, :opts, :level_queue
+      attr_reader :context, :plan, :many, :opts, :level_queue, :presenter
 
       # @param plan [SeregaPlan] Serialization plan
       # @param context [Hash] Serialization context
@@ -30,6 +30,8 @@ class Serega
         @many = many
         @opts = opts
         @level_queue = opts[:level_queue]
+        # Looked up once here and reused for every enqueued chunk of the level.
+        @presenter = self.class.serializer_class.presenter
       end
 
       # Enqueues this level and returns its result container(s). The containers are
@@ -78,9 +80,14 @@ class Serega
       # containers. This is where objects enter their level, so every object a
       # point resolves against and a batch loader receives has the same shape.
       #
-      # Patched in:
-      # - plugin :presenter (wraps each object in a Presenter before enqueueing)
+      # Each object is wrapped in the serializer's presenter before it is enqueued,
+      # so the whole level — value resolution and batch loaders alike — sees
+      # presenters. Serializers without a presenter enqueue the objects as they
+      # are — wrapping would only add overhead and break class checks
+      # (object.is_a?, Hash === object) without changing anything.
       def enqueue(objects)
+        objects = objects.map { |object| presenter.new(object, context) } if presenter
+
         level_queue.enqueue(self, objects)
       end
 

data/lib/serega/plan_point.rb

@@ -85,12 +85,18 @@ class Serega
       # Runs this point's declared preloads over the given objects using the
       # serializer's registered preload handler.
       #
+      # Presenters are unwrapped first, as preload handlers work with the
+      # serialized objects themselves.
+      #
       # @param objects [Array] objects serialized at this point's level
       # @return [void]
       def run_preloads(objects)
         return unless preloads
 
-        handler = self.class.serializer_class.preload_with
+        serializer_class = self.class.serializer_class
+        objects = objects.map(&:__getobj__) if serializer_class.presenter
+
+        handler = serializer_class.preload_with
         unless handler
           raise SeregaError, "The :preload option requires a preload handler. Register one with `preload_with` (the :activerecord_preloads plugin does this for you)."
         end

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

@@ -88,28 +88,9 @@ class Serega
       # @private
       def self.after_load_plugin(serializer_class, **_opts)
         serializer_class.preload_with do |objects, preloads|
-          Preloader.preload(ActiverecordPreloads.records(serializer_class, objects), preloads)
+          Preloader.preload(objects, preloads)
         end
       end
-
-      #
-      # The underlying records to preload onto. The :presenter plugin wraps every
-      # serialized object in a SimpleDelegator, but ActiveRecord's Preloader needs
-      # the real records, so unwrap them via #__getobj__ when presenter is used.
-      # Objects are wrapped only when the Presenter class has custom methods.
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param objects [Array] objects serialized at the current level
-      #
-      # @return [Array] the underlying records
-      #
-      # @private
-      def self.records(serializer_class, objects)
-        return objects unless serializer_class.plugin_used?(:presenter)
-        return objects unless serializer_class.custom_presenter?
-
-        objects.map(&:__getobj__)
-      end
     end
 
     register_plugin(ActiverecordPreloads.plugin_name, ActiverecordPreloads)

data/lib/serega/plugins.rb

@@ -30,10 +30,10 @@ class Serega
       # @raise [SeregaError] Raises SeregaError when plugin was not found
       #
       # @example Find plugin when providing name
-      #   SeregaPlugins.find_plugin(:presenter) # => SeregaPlugins::Presenter
+      #   SeregaPlugins.find_plugin(:root) # => SeregaPlugins::Root
       #
       # @example Find plugin when providing plugin itself
-      #   SeregaPlugins.find_plugin(Presenter) # => Presenter
+      #   SeregaPlugins.find_plugin(Root) # => Root
       #
       # @return [Class<Module>] Plugin core module
       #

data/lib/serega/presenter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+class Serega
+  #
+  # Wraps the serialized object, so computed attribute values can be defined as
+  # methods instead of `:value` callables.
+  #
+  # SeregaPresenter inherits from SimpleDelegator:
+  # - All methods of the serialized object are available directly inside presenter methods.
+  # - Methods not defined on SeregaPresenter 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
+  # SeregaPresenter class, so multiple blocks accumulate.
+  #
+  # @example
+  #   class UserSerializer < Serega
+  #     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
+  #
+  # @private
+  class SeregaPresenter < SimpleDelegator
+    #
+    # @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
+
+    extend Forwardable
+  end
+end

data/lib/serega.rb

@@ -62,6 +62,7 @@ require_relative "serega/validations/check_batch_loader_params"
 require_relative "serega/validations/check_serialize_params"
 
 require_relative "serega/config"
+require_relative "serega/presenter"
 require_relative "serega/object_serializer"
 require_relative "serega/plan_point"
 require_relative "serega/plan"
@@ -70,6 +71,7 @@ require_relative "serega/plugins"
 
 class Serega
   @config = SeregaConfig.new
+  @presenter_class = nil
 
   # Validates `Serializer.attribute` params
   check_attribute_params_class = Class.new(SeregaValidations::CheckAttributeParams)
@@ -170,10 +172,17 @@ class Serega
     end
 
     #
-    # Adds attribute
+    # Lists blocks given to `presenter`, in definition order
     #
-    # Patched in:
-    # - plugin :presenter (additionally adds method in Presenter class)
+    # @return [Array<Proc>] presenter blocks list
+    #
+    # @private
+    def presenter_blocks
+      @presenter_blocks ||= []
+    end
+
+    #
+    # Adds attribute
     #
     # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
     # @param opts [Hash] Options to serialize attribute
@@ -233,6 +242,30 @@ class Serega
       batch_loaders[batch_loader.name] = batch_loader
     end
 
+    #
+    # 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
+    #
+    # @param block [Proc] Presenter methods
+    #
+    # @return [Class<SeregaPresenter>, nil] the serializer presenter class,
+    #   nil when the serializer has none
+    #
+    def presenter(&block)
+      return @presenter_class unless block
+
+      @presenter_class ||= Class.new(SeregaPresenter)
+      @presenter_class.class_exec(&block)
+      presenter_blocks << block
+      @presenter_class
+    end
+
     #
     # Registers (or returns) the handler used to preload an attribute's
     # associations onto the records gathered during serialization.
@@ -378,7 +411,6 @@ class Serega
 
     # Patched in:
     # - plugin :metadata (defines MetaAttribute and copies meta_attributes to subclasses)
-    # - plugin :presenter (defines Presenter)
     def inherited(subclass)
       config_class = Class.new(self::SeregaConfig)
       config_class.serializer_class = subclass
@@ -446,6 +478,11 @@ class Serega
       # Assign same initial objects handler
       subclass.prepare_initial_objects(prepare_initial_objects) if prepare_initial_objects
 
+      # Assign same presenter blocks
+      presenter_blocks.each do |presenter_block|
+        subclass.presenter(&presenter_block)
+      end
+
       super
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Andrey
@@ -64,10 +64,10 @@ files:
 - lib/serega/plugins/metadata/validations/check_opt_value.rb
 - lib/serega/plugins/metadata/validations/check_opts.rb
 - lib/serega/plugins/metadata/validations/check_path.rb
-- lib/serega/plugins/presenter/presenter.rb
 - lib/serega/plugins/root/root.rb
 - lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
+- lib/serega/presenter.rb
 - lib/serega/utils/collection_detector.rb
 - lib/serega/utils/enum_deep_dup.rb
 - lib/serega/utils/enum_deep_freeze.rb

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