Include information about objects' and collections' parents

Author: jhollinger

lib/blueprinter/v2/context.rb

@@ -55,16 +55,25 @@ module Context
       #   @return [Hash] Options passed to `render`
       # @!attribute [r] object
       #   @return [Object] The object or collection that's currently being rendered
+      # @!attribute [r] parent
+      #   @return [Blueprinter::V2::Context::Parent] Information about the parent, if any
       # @!attribute [r] depth
       #   @return [Integer] Blueprint depth (1-indexed)
       #
-      Object = Struct.new(:blueprint, :fields, :options, :object, :depth) do
+      Object = Struct.new(:blueprint, :fields, :options, :object, :parent, :depth) do
         (members - %i[object]).each do |attr|
           remove_method("#{attr}=")
           define_method("#{attr}=") { |_| raise BlueprinterError, "Context field `#{attr}` is immutable" }
         end
       end
 
+      Parent = Struct.new(:blueprint, :field, :object) do
+        members.each do |attr|
+          remove_method("#{attr}=")
+          define_method("#{attr}=") { |_| raise BlueprinterError, "Parent field `#{attr}` is immutable" }
+        end
+      end
+
       #
       # The current field.
       #

lib/blueprinter/v2/field_serializers/collection.rb

@@ -31,8 +31,9 @@ def serialize(ctx, result)
         def blueprint_value(value, ctx)
           field_blueprint = ctx.field.blueprint
           if @instances.blueprint(field_blueprint).is_a? V2::Base
+            parent = Context::Parent.new(ctx.blueprint.class, ctx.field, ctx.object)
             child_serializer = @instances.serializer(field_blueprint, ctx.options, ctx.depth + 1)
-            child_serializer.collection(value, depth: ctx.depth + 1)
+            child_serializer.collection(value, parent:, depth: ctx.depth + 1)
           else
             opts = { v2_instances: @instances, v2_depth: ctx.depth }
             field_blueprint.hashify(value, view_name: :default, local_options: ctx.options.dup.merge(opts))

lib/blueprinter/v2/field_serializers/object.rb

@@ -31,8 +31,9 @@ def serialize(ctx, result)
         def blueprint_value(value, ctx)
           field_blueprint = ctx.field.blueprint
           if @instances.blueprint(field_blueprint).is_a? V2::Base
+            parent = Context::Parent.new(ctx.blueprint.class, ctx.field, ctx.object)
             child_serializer = @instances.serializer(field_blueprint, ctx.options, ctx.depth + 1)
-            child_serializer.object(value, depth: ctx.depth + 1)
+            child_serializer.object(value, parent:, depth: ctx.depth + 1)
           else
             opts = { v2_instances: @instances, v2_depth: ctx.depth }
             field_blueprint.hashify(value, view_name: :default, local_options: ctx.options.dup.merge(opts))

lib/blueprinter/v2/serializer.rb

@@ -42,41 +42,45 @@ def initialize(blueprint_class, options, instances, initial_depth:)
       # Serialize a single object to a Hash.
       #
       # @param object [Object] The object to serialize
+      # @param depth [Object] Depth of this object in the serialization tree
+      # @param parent [Blueprinter::V2::Context::Parent] Information about the container object (if any)
       # @return [Hash] The serialized object
       #
-      def object(object, depth:)
+      def object(object, depth:, parent: nil)
         if @hook_around_serialize_object
-          ctx = Context::Object.new(@blueprint, @fields, @options, object, depth)
+          ctx = Context::Object.new(@blueprint, @fields, @options, object, parent, depth)
           @hooks.around(:around_serialize_object, ctx) do |ctx|
-            serialize_object(ctx.object, depth:)
+            serialize_object(ctx.object, depth:, parent:)
           end
         else
-          serialize_object(object, depth:)
+          serialize_object(object, depth:, parent:)
         end
       end
 
       #
       # Serialize a collection of objects to a Hash.
       #
       # @param collection [Enumerable] The collection to serialize
+      # @param depth [Object] Depth of this object in the serialization tree
+      # @param parent [Blueprinter::V2::Context::Parent] Information about the container object (if any)
       # @return [Enumerable] The serialized hashes
       #
-      def collection(collection, depth:)
+      def collection(collection, depth:, parent: nil)
         if @hook_around_serialize_collection
-          ctx = Context::Object.new(@blueprint, @fields, @options, collection, depth)
+          ctx = Context::Object.new(@blueprint, @fields, @options, collection, parent, depth)
           @hooks.around(:around_serialize_collection, ctx) do |ctx|
-            ctx.object.map { |object| serialize_object(object, depth:) }.to_a
+            ctx.object.map { |object| serialize_object(object, depth:, parent:) }.to_a
           end
         else
-          collection.map { |object| serialize_object(object, depth:) }.to_a
+          collection.map { |object| serialize_object(object, depth:, parent:) }.to_a
         end
       end
 
       private
 
-      def serialize_object(object, depth:)
+      def serialize_object(object, depth:, parent: nil)
         if @hook_around_blueprint
-          ctx = Context::Object.new(@blueprint, @fields, @options, object, depth)
+          ctx = Context::Object.new(@blueprint, @fields, @options, object, parent, depth)
           @hooks.around(:around_blueprint, ctx) do |ctx|
             serialize(ctx.object, depth:)
           end

spec/v2/serializer_spec.rb

@@ -111,41 +111,6 @@ def around_collection_value(ctx)
       })
     end
 
-    # it 'uses field-level extractor (class)' do
-    #   test = self
-    #   blueprint = Class.new(application_blueprint) do
-    #     self.blueprint_name = "BlockBlueprint"
-    #     field :name, extractor: test.name_of_extractor
-    #     object :category, test.category_blueprint, extractor: test.name_of_extractor
-    #     collection :parts, test.part_blueprint, extractor: test.name_of_extractor
-    #   end
-
-    #   result = described_class.new(blueprint, {}, instances, initial_depth: 1).object(widget, depth: 1)
-    #   expect(result).to eq({
-    #     name: 'Name of Foo',
-    #     category: { name: 'Name of Bar' },
-    #     parts: [{ num: 1 }, { num: 2 }]
-    #   })
-    # end
-
-    # it 'uses field-level extractor (instance)' do
-    #   test = self
-    #   blueprint = Class.new(application_blueprint) do
-    #     self.blueprint_name = "BlockBlueprint"
-    #     extensions << test.name_of_extractor.new
-    #     field :name, extractor: test.name_of_extractor.new(prefix: 'X')
-    #     object :category, test.category_blueprint, extractor: test.name_of_extractor.new(prefix: 'Y')
-    #     collection :parts, test.part_blueprint, extractor: test.name_of_extractor.new
-    #   end
-
-    #   result = described_class.new(blueprint, {}, instances, initial_depth: 1).object(widget, depth: 1)
-    #   expect(result).to eq({
-    #     name: 'X of Foo',
-    #     category: { name: 'Y of Bar' },
-    #     parts: [{ num: 1 }, { num: 2 }]
-    #   })
-    # end
-
     it 'uses blueprint extractor extension' do
       test = self
       blueprint = Class.new(application_blueprint) do
@@ -504,4 +469,43 @@ def instances.blueprints = @blueprints
     blueprint_instances = instances.blueprints.count
     expect(blueprint_instances).to eq 1
   end
+
+  it 'passes objects information about the parent' do
+    ext = Class.new(Blueprinter::Extension) do
+      def initialize(log) = @log = log
+
+      def around_serialize_object(ctx)
+        if ctx.parent
+          @log << "Object Parent Blueprint: #{ctx.parent.blueprint}"
+          @log << "Object Parent field: #{ctx.parent.field.name}"
+          @log << "Object Parent object: #{ctx.parent.object[:name]}"
+        end
+        yield ctx
+      end
+
+      def around_serialize_collection(ctx)
+        if ctx.parent
+          @log << "Collection Parent Blueprint: #{ctx.parent.blueprint}"
+          @log << "Collection Parent field: #{ctx.parent.field.name}"
+          @log << "Collection Parent object: #{ctx.parent.object[:name]}"
+        end
+        yield ctx
+      end
+    end
+    log = []
+    category_blueprint.extensions << ext.new(log)
+    part_blueprint.extensions << ext.new(log)
+    serializer = described_class.new(widget_blueprint, {}, instances, initial_depth: 1)
+
+    widget = { name: 'Foo', category: { name: 'Bar' }, parts: [{ num: 42 }] }
+    result = serializer.object(widget, depth: 1)
+    expect(log).to eq [
+      "Object Parent Blueprint: WidgetBlueprint",
+      "Object Parent field: category",
+      "Object Parent object: Foo",
+      "Collection Parent Blueprint: WidgetBlueprint",
+      "Collection Parent field: parts",
+      "Collection Parent object: Foo"
+    ]
+  end
 end