lutaml-model 0.7.5 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99264c5157019d0cddfc59098e9603152db0a2d84caa8c9710a9c6a165f39cc4
-  data.tar.gz: 34886a6307aa6b6bb2211925477272c7a1412b67c7ef6695ea495a211bc0e540
+  metadata.gz: 073512f7cfe8a5d5bb7af56cf3c1804e0eb9942f9fe2e3f7e0dcc3b0b9fd879a
+  data.tar.gz: '00916ad5bc08547bd350f59be3c554700cd73c1b5af09e2ce7175f39d3443e45'
 SHA512:
-  metadata.gz: f1f358820c85b0626fade2aaac1ff1c3a408c0e267e22b25165d133b92adccbf31c2ca969099dbd441c1fbfc8d9833e5b1ff43fcdf079f6523e769f28bef91c5
-  data.tar.gz: c2799042e4d91fedd894c7f86c34f79ecc93509e4422b5f204aef1f5eb5150133e120fa442477c39185c210fe65c6fcb844bb6764e3833a6828235a4e9551054
+  metadata.gz: '0196826861701d9277a81f5e0c52fd0bfdac8859128eddb82aee55c074a3688bc453f89ff40f54f8a40a639d5ac625d18e6f097c4abb88f7ee11294b7594e1ff'
+  data.tar.gz: 50fb93a7b534ae371ebecc62576633027a9cc945ed333cdbc7aa3c32a993a558b196dde0513aa594796cfb442c2837158c9181a101351933778009e4e5a00a05

data/.github/workflows/dependent-tests.yml

@@ -4,7 +4,11 @@ on:
   push:
     branches: [ main ]
     tags: [ v* ]
+    paths-ignore:
+      - '**.adoc'
   pull_request:
+    paths-ignore:
+      - '**.adoc'
   workflow_dispatch:
   repository_dispatch:
     types: [ release-passed ]

data/.github/workflows/rake.yml

@@ -6,10 +6,22 @@ on:
   push:
     branches: [ master, main ]
     tags: [ v* ]
+    paths-ignore:
+      - '**.adoc'
   pull_request:
+    paths-ignore:
+      - '**.adoc'
 
 jobs:
   rake:
     uses: metanorma/ci/.github/workflows/generic-rake.yml@main
+    with:
+      before-setup-ruby: |
+        mkdir -p .bundle
+        touch .bundle/config
+        cat .bundle/config
+        echo "---" >> .bundle/config
+        echo 'BUNDLE_BUILD__RUBY___LL: "--with-cflags=-std=gnu17"' >> .bundle/config
+        cat .bundle/config
     secrets:
       pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/README.adoc

@@ -1813,7 +1813,7 @@ invalid_xml = <<~XML
   <zip>12345</zip>
 </Person>
 XML
-Person.from_xml(valid_xml) # #<Person:0x00000002d56b3988 @city="Metropolis", @name="John Doe", @street="123 Main St", @zip="12345"> 
+Person.from_xml(valid_xml) # #<Person:0x00000002d56b3988 @city="Metropolis", @name="John Doe", @street="123 Main St", @zip="12345">
 Person.from_xml(invalid_xml) # raises `Element `zip` does not match the expected sequence order element `city` (Lutaml::Model::IncorrectSequenceError)`
 ----
 ====
@@ -1835,7 +1835,7 @@ class ContactEmail < Lutaml::Model::Serializable
   attribute :email, :string
 
   xml do
-    no_root 
+    no_root
 
     map_element :email, to: :email
   end
@@ -3151,6 +3151,123 @@ authors.first.name
 ====
 
 
+==== Nested keyed object collection
+
+A nested keyed object collection is a keyed collection that contain other keyed
+collections. This case is simply a more complex arrangement of the principles
+applied to keyed object collections.
+
+This pattern can extend to multiple levels of nesting, where each level contains
+a keyed object collection that can have its own key and value mappings.
+
+Depends on whether a custom collection class is needed, the following
+mechanisms are available:
+
+* When using a Lutaml::Model::Serializable class for a keyed collection,
+use the `child_mappings` option to map attributes.
+
+* When using a Lutaml::Model::Collection class for a keyed collection,
+there are two options:
+
+* use the `map_key`, `map_value`, and `map_instances` methods to map attributes;
+or
+
+* use the `root_mappings` option to map attributes.
+
+
+.Nested 2-layer keyed object collection
+[example]
+====
+This example provides a two-layer nested structure where:
+
+* The first layer keys pieces by type (`bowls`, `vases`).
+* The second layer keys glazes by finish name within each piece type.
+* Each glaze finish contains detailed attributes like temperature.
+
+[source,ruby]
+----
+# Third layer represents glaze finishes.
+class GlazeFinish < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :temperature, :integer
+
+  key_value do
+    map "name", to: :name
+    map "temperature", to: :temperature
+  end
+end
+
+# Second layer represents ceramic pieces each with multiple finishes.
+class CeramicPiece < Lutaml::Model::Serializable
+  attribute :piece_type, :string
+  attribute :glazes, GlazeFinish, collection: true
+
+  key_value do
+    map "piece_type", to: :piece_type
+    map "glazes", to: :glazes, child_mappings: {
+      name: :key,
+      temperature: :temperature
+    }
+  end
+end
+
+# Uppermost layer represents the collection of ceramic pieces.
+class StudioInventory < Lutaml::Model::Collection
+  instances :pieces, CeramicPiece
+
+  key_value do
+    map to: :pieces, root_mappings: {
+      piece_type: :key,
+      glazes: :value,
+    }
+  end
+end
+----
+
+[source,yaml]
+----
+---
+bowls:
+  matte_finish:
+    name: Earth Matte
+    temperature: 1240
+  glossy_finish:
+    name: Ocean Blue
+    temperature: 1260
+  crackle_finish:
+    name: Antique Crackle
+    temperature: 1220
+vases:
+  metallic_finish:
+    name: Bronze Metallic
+    temperature: 1280
+  crystalline_finish:
+    name: Ice Crystal
+    temperature: 1300
+----
+
+[source,ruby]
+----
+inventory = StudioInventory.from_yaml(yaml_data)
+
+# Access nested data through the hierarchy
+puts inventory.pieces.bowls.matte_finish.name
+# => "Earth Matte"
+
+puts inventory.pieces.bowls.matte_finish.temperature
+# => 1240
+
+# Iterate through all pieces and their glazes
+inventory.pieces.each do |piece_type, piece|
+  puts "#{piece_type.capitalize}:"
+  piece.glazes.each do |glaze_name, glaze|
+    puts "  #{glaze_name}: #{glaze.name} (#{glaze.temperature}°C)"
+  end
+end
+----
+====
+
+
 
 
 === Behavior

data/lib/lutaml/model/collection.rb

@@ -87,15 +87,15 @@ module Lutaml
         end
       end
 
-      attr_reader :register
+      attr_reader :__register
 
-      def initialize(items = [], register: Lutaml::Model::Config.default_register)
+      def initialize(items = [], __register: Lutaml::Model::Config.default_register)
         super()
 
-        @register = register
+        @__register = __register
         items = [items].compact unless items.is_a?(Array)
 
-        register_object = Lutaml::Model::GlobalRegister.lookup(register)
+        register_object = Lutaml::Model::GlobalRegister.lookup(@__register)
         type = register_object.get_class_without_register(self.class.instance_type)
         self.collection = items.map do |item|
           if item.is_a?(type)
@@ -103,7 +103,8 @@ module Lutaml
           elsif type <= Lutaml::Model::Type::Value
             type.cast(item)
           else
-            type.new(item, register: register)
+            item[:__register] = __register
+            type.new(item)
           end
         end
 

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -289,7 +289,7 @@ module Lutaml
         delegate_value = model.public_send(delegate)
         return if Utils.initialized?(delegate_value) && !delegate_value.nil?
 
-        model.public_send(:"#{delegate}=", attributes[delegate].type(model.register).new)
+        model.public_send(:"#{delegate}=", attributes[delegate].type(model.__register).new)
       end
 
       def handle_transform_method(model, value, attributes)

data/lib/lutaml/model/serialize.rb

@@ -123,7 +123,7 @@ module Lutaml
             end
             define_method(:"#{name}=") do |value|
               value_set_for(name)
-              instance_variable_set(:"@#{name}", attr.cast_value(value, register))
+              instance_variable_set(:"@#{name}", attr.cast_value(value, __register))
             end
           end
         end
@@ -412,7 +412,7 @@ module Lutaml
           instance = if options.key?(:instance)
                        options[:instance]
                      elsif model.include?(Lutaml::Model::Serialize)
-                       model.new({}, register: register)
+                       model.new({ __register: register })
                      else
                        object = model.new
                        register_accessor_methods_for(object, register)
@@ -438,7 +438,7 @@ module Lutaml
           klass_name = polymorphic_mapping.polymorphic_map[klass_key]
           klass = Object.const_get(klass_name)
 
-          klass.apply_mappings(doc, format, options.merge(register: instance.register))
+          klass.apply_mappings(doc, format, options.merge(register: instance.__register))
         end
 
         def apply_value_map(value, value_map, attr)
@@ -485,13 +485,13 @@ module Lutaml
         end
 
         def register_accessor_methods_for(object, register)
-          Utils.add_singleton_method_if_not_defined(object, :register) do
-            @register
+          Utils.add_singleton_method_if_not_defined(object, :__register) do
+            @__register
           end
-          Utils.add_singleton_method_if_not_defined(object, :register=) do |value|
-            @register = value
+          Utils.add_singleton_method_if_not_defined(object, :__register=) do |value|
+            @__register = value
           end
-          object.register = register
+          object.__register = register
         end
 
         def extract_register_id(register)
@@ -583,20 +583,21 @@ module Lutaml
         end
       end
 
-      attr_accessor :element_order, :schema_location, :encoding, :register
+      attr_accessor :element_order, :schema_location, :encoding, :__register
       attr_writer :ordered, :mixed
 
       def initialize(attrs = {}, options = {})
         @using_default = {}
         return unless self.class.attributes
 
-        @register = extract_register_id(options[:register])
+        @__register = extract_register_id(attrs, options)
         set_ordering(attrs)
         set_schema_location(attrs)
         initialize_attributes(attrs, options)
       end
 
-      def extract_register_id(register)
+      def extract_register_id(attrs, options)
+        register = attrs&.dig(:__register) || options&.dig(:register)
         self.class.extract_register_id(register)
       end
 
@@ -609,8 +610,8 @@ module Lutaml
       end
 
       def attr_value(attrs, name, attribute)
-        value = Utils.fetch_str_or_sym(attrs, name, attribute.default(register))
-        attribute.cast_value(value, register)
+        value = Utils.fetch_str_or_sym(attrs, name, attribute.default(__register))
+        attribute.cast_value(value, __register)
       end
 
       def using_default_for(attribute_name)
@@ -670,7 +671,7 @@ module Lutaml
       end
 
       def pretty_print_instance_variables
-        (instance_variables - %i[@using_default]).sort
+        (instance_variables - %i[@using_default @__register]).sort
       end
 
       def to_yaml_hash
@@ -722,9 +723,9 @@ module Lutaml
       def determine_value(attrs, name, attr)
         if attrs.key?(name) || attrs.key?(name.to_s)
           attr_value(attrs, name, attr)
-        elsif attr.default_set?(register)
+        elsif attr.default_set?(__register)
           using_default_for(name)
-          attr.default(register)
+          attr.default(__register)
         else
           Lutaml::Model::UninitializedClass.instance
         end

data/lib/lutaml/model/transform/key_value_transform.rb

@@ -2,11 +2,12 @@ module Lutaml
   module Model
     class KeyValueTransform < Lutaml::Model::Transform
       def data_to_model(data, format, options = {})
-        instance = if model_class.include?(Lutaml::Model::Serialize)
-                     model_class.new({}, register: register)
-                   else
-                     model_class.new(register)
-                   end
+        if model_class.include?(Lutaml::Model::Serialize)
+          instance = model_class.new(__register: __register)
+        else
+          instance = model_class.new
+          register_accessor_methods_for(instance, __register)
+        end
         mappings = extract_mappings(options, format)
 
         Utils.add_if_present(options, :key_mappings, mappings.key_mappings)
@@ -93,7 +94,7 @@ module Lutaml
       end
 
       def serialize_value(value, rule, attr, format, options)
-        return attr.serialize(value, format, register, options) unless rule.child_mappings
+        return attr.serialize(value, format, __register, options) unless rule.child_mappings
 
         generate_hash_from_child_mappings(
           attr, value, format, rule.child_mappings
@@ -111,12 +112,12 @@ module Lutaml
 
         generate_remaining_mappings_for_value(child_mappings, value, format)
 
-        attr_type = attr.type(register)
+        attr_type = attr.type(__register)
         value.each do |child_obj|
           rules = attr_type.mappings_for(format)
 
           hash.merge!(
-            extract_hash_for_child_mapping(child_mappings, child_obj, rules),
+            extract_hash_for_child_mapping(child_mappings, child_obj, rules, format),
           )
         end
 
@@ -144,14 +145,13 @@ module Lutaml
         mappings.find_by_to(name)&.name.to_s
       end
 
-      def extract_hash_for_child_mapping(child_mappings, child_obj, rules)
+      def extract_hash_for_child_mapping(child_mappings, child_obj, rules, format)
         key = nil
         value = {}
 
         child_mappings.each do |attr_name, path|
           rule = rules.find_by_to(attr_name)
-
-          attr_value = normalize_attribute_value(child_obj.send(attr_name))
+          attr_value = normalize_attribute_value(child_obj, rule.from, format)
 
           next unless rule&.render?(attr_value, nil)
           next key = attr_value if path == :key
@@ -163,14 +163,10 @@ module Lutaml
         { key => value }
       end
 
-      def normalize_attribute_value(value)
-        if value.is_a?(Lutaml::Model::Serialize)
-          value.to_hash
-        elsif value.is_a?(Array) && value.first.is_a?(Lutaml::Model::Serialize)
-          value.map(&:to_hash)
-        else
-          value
-        end
+      def normalize_attribute_value(value, attr_name, format)
+        Lutaml::Model::Config.adapter_for(format).parse(
+          value.public_send(:"to_#{format}"),
+        )[attr_name.to_s]
       end
 
       def extract_hash_value_for_child_mapping(path, value, map_value)
@@ -189,7 +185,7 @@ module Lutaml
         return if value.nil? && !rule.render_nil
 
         attribute = instance.send(rule.delegate).class.attributes[rule.to]
-        hash[rule_from_name(rule)] = attribute.serialize(value, format, register)
+        hash[rule_from_name(rule)] = attribute.serialize(value, format, __register)
       end
 
       def extract_value_for_delegate(instance, rule)
@@ -206,7 +202,7 @@ module Lutaml
 
         raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule, attr)
 
-        value = rule_value_extractor_class.call(rule, doc, format, attr, register, options)
+        value = rule_value_extractor_class.call(rule, doc, format, attr, __register, options)
         value = apply_value_map(value, rule.value_map(:from, options), attr)
 
         return process_custom_method(rule, instance, value) if rule.has_custom_method_for_deserialization?
@@ -226,7 +222,7 @@ module Lutaml
 
       def cast_value(value, attr, format, rule)
         cast_options = rule.polymorphic ? { polymorphic: rule.polymorphic } : {}
-        attr.cast(value, format, register, cast_options)
+        attr.cast(value, format, __register, cast_options)
       end
 
       def translate_mappings(hash, child_mappings, attr, format)
@@ -248,7 +244,7 @@ module Lutaml
       end
 
       def build_child_hash(key, value, child_mappings, attr, format)
-        attr_type = attr.type(register)
+        attr_type = attr.type(__register)
         child_mappings.to_h do |attr_name, path|
           attr_value = extract_attr_value(path, key, value)
           attr_rule = attr_type.mappings_for(format).find_by_to(attr_name)
@@ -271,7 +267,7 @@ module Lutaml
       end
 
       def map_child_data(child_hash, attr, format)
-        attr_type = attr.type(register)
+        attr_type = attr.type(__register)
         self.class.data_to_model(
           attr_type,
           child_hash,

data/lib/lutaml/model/transform/xml_transform.rb

@@ -3,10 +3,10 @@ module Lutaml
     class XmlTransform < Lutaml::Model::Transform
       def data_to_model(data, _format, options = {})
         if model_class.include?(Lutaml::Model::Serialize)
-          instance = model_class.new({}, register: register)
+          instance = model_class.new({ __register: __register })
         else
           instance = model_class.new
-          register_accessor_methods_for(instance, register)
+          register_accessor_methods_for(instance, __register)
         end
         apply_xml_mapping(data, instance, options)
       end
@@ -53,7 +53,7 @@ module Lutaml
 
                     if (val.nil? || Utils.uninitialized?(val)) && (instance.using_default?(rule.to) || rule.render_default)
                       defaults_used << rule.to
-                      attr&.default(register) || rule.to_value_for(instance)
+                      attr&.default(__register) || rule.to_value_for(instance)
                     else
                       val
                     end
@@ -114,7 +114,7 @@ module Lutaml
         return doc.root.find_attribute_value(rule_names) if rule.attribute?
 
         attr = attribute_for_rule(rule)
-        attr_type = attr&.type(register)
+        attr_type = attr&.type(__register)
 
         children = doc.children.select do |child|
           rule_names.include?(child.namespaced_name) && !child.text?
@@ -136,9 +136,9 @@ module Lutaml
           if !rule.has_custom_method_for_deserialization? && attr_type <= Serialize
             cast_options = options.except(:mappings)
             cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
-            cast_options[:register] = register
+            cast_options[:register] = __register
 
-            values << attr.cast(child, :xml, register, cast_options)
+            values << attr.cast(child, :xml, __register, cast_options)
           elsif attr.raw?
             values << inner_xml_of(child)
           else
@@ -179,7 +179,7 @@ module Lutaml
 
         return value unless cast_value?(attr, rule)
 
-        attr.cast(value, :xml, register, options)
+        attr.cast(value, :xml, __register, options)
       end
 
       def cast_value?(attr, rule)

data/lib/lutaml/model/transform.rb

@@ -6,15 +6,16 @@ module Lutaml
       end
 
       def self.model_to_data(context, model, format, options = {})
-        new(context, model.register).model_to_data(model, format, options)
+        register = model.__register if model.respond_to?(:__register)
+        new(context, register).model_to_data(model, format, options)
       end
 
-      attr_reader :context, :attributes, :register
+      attr_reader :context, :attributes, :__register
 
       def initialize(context, register = nil)
         @context = context
         @attributes = context.attributes
-        @register = register || Lutaml::Model::Config.default_register
+        @__register = register || Lutaml::Model::Config.default_register
       end
 
       def model_class
@@ -71,18 +72,18 @@ module Lutaml
       def attribute_for_rule(rule)
         return attributes[rule.to] unless rule.delegate
 
-        attributes[rule.delegate].type(register).attributes[rule.to]
+        attributes[rule.delegate].type(__register).attributes[rule.to]
       end
 
       def register_accessor_methods_for(object, register)
         klass = object.class
-        Utils.add_method_if_not_defined(klass, :register) do
-          @register
+        Utils.add_method_if_not_defined(klass, :__register) do
+          @__register
         end
-        Utils.add_method_if_not_defined(klass, :register=) do |value|
-          @register = value
+        Utils.add_method_if_not_defined(klass, :__register=) do |value|
+          @__register = value
         end
-        object.register = register
+        object.__register = register
       end
     end
   end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.7.5"
+    VERSION = "0.7.6"
   end
 end

data/lib/lutaml/model/xml/document.rb

@@ -443,10 +443,10 @@ module Lutaml
 
           return_register = if register.is_a?(Lutaml::Model::Register)
                               register.id
-                            elsif @root.respond_to?(:register)
-                              @root.register
-                            elsif @root.instance_variable_defined?(:@register)
-                              @root.instance_variable_get(:@register)
+                            elsif @root.respond_to?(:__register)
+                              @root.__register
+                            elsif @root.instance_variable_defined?(:@__register)
+                              @root.instance_variable_get(:@__register)
                             end
           return_register || Lutaml::Model::Config.default_register
         end

data/spec/lutaml/model/custom_model_spec.rb

@@ -1,19 +1,11 @@
 require "spec_helper"
 
 class CustomModelChild
-  attr_accessor :street, :city, :register
-
-  def initialize(register = nil)
-    @register = register
-  end
+  attr_accessor :street, :city
 end
 
 class CustomModelParent
-  attr_accessor :first_name, :middle_name, :last_name, :child_mapper, :math, :register
-
-  def initialize(register = nil)
-    @register = register
-  end
+  attr_accessor :first_name, :middle_name, :last_name, :child_mapper, :math
 
   def name
     "#{first_name} #{last_name}"
@@ -21,11 +13,7 @@ class CustomModelParent
 end
 
 class GenericFormulaClass
-  attr_accessor :value, :register
-
-  def initialize(register = nil)
-    @register = register
-  end
+  attr_accessor :value
 end
 
 class Mi < Lutaml::Model::Serializable

data/spec/lutaml/model/defaults_spec.rb

@@ -108,11 +108,7 @@ module DefaultsSpec
 
   # Class for testing render_default: true with custom model
   class Lang
-    attr_accessor :lang, :content, :register
-
-    def initialize(register = nil)
-      @register = register
-    end
+    attr_accessor :lang, :content
   end
 
   class CustomModelWithDefaultValue < Lutaml::Model::Serializable

data/spec/lutaml/model/register/xml_spec.rb

@@ -111,9 +111,7 @@ RSpec.describe "RegisterXmlSpec" do
           {
             numerator: RegisterXmlSpec::Mo.new(value: "a"),
             denominator: RegisterXmlSpec::Mi.new(value: "b"),
-          },
-          {
-            register: register,
+            __register: register,
           },
         ),
       )

data/spec/lutaml/model/xml/root_mappings/nested_child_mappings_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+module NestedChildMappingsSpec
+  class ManifestFont < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :styles, :string, collection: true
+
+    key_value do
+      map "name", to: :name
+      map "styles", to: :styles
+    end
+  end
+
+  class ManifestResponseFontStyle < Lutaml::Model::Serializable
+    attribute :full_name, :string
+    attribute :type, :string
+    attribute :paths, :string, collection: true
+
+    key_value do
+      map "full_name", to: :full_name
+      map "type", to: :type
+      map "paths", to: :paths
+    end
+  end
+
+  class ManifestResponseFont < ManifestFont
+    attribute :name, :string
+    attribute :styles, ManifestResponseFontStyle, collection: true
+
+    key_value do
+      map "name", to: :name
+      map "styles", to: :styles, child_mappings: {
+        type: :key,
+        full_name: :full_name,
+        paths: :paths,
+      }
+    end
+  end
+
+  class ManifestResponse < Lutaml::Model::Collection
+    instances :fonts, ManifestResponseFont
+
+    key_value do
+      map to: :fonts, root_mappings: {
+        name: :key,
+        styles: :value,
+      }
+    end
+  end
+end
+
+RSpec.describe "NestedChildMappingsSpec" do
+  let(:yaml) do
+    <<~YAML
+      ---
+      Yu Gothic:
+        Bold:
+          full_name: Yu Gothic Bold
+          paths:
+          - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothB.ttc"
+        Regular:
+          full_name: Yu Gothic Regular
+          paths:
+          - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothR.ttc"
+      Noto Sans Condensed:
+        Regular:
+          full_name: Noto Sans Condensed
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-Condensed.ttf"
+        Bold:
+          full_name: Noto Sans Condensed Bold
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedBold.ttf"
+        Bold Italic:
+          full_name: Noto Sans Condensed Bold Italic
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedBoldItalic.ttf"
+        Italic:
+          full_name: Noto Sans Condensed Italic
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedItalic.ttf"
+    YAML
+  end
+
+  let(:parsed_yaml) do
+    NestedChildMappingsSpec::ManifestResponse.from_yaml(yaml)
+  end
+
+  let(:expected_fonts) do
+    NestedChildMappingsSpec::ManifestResponse.new(
+      [
+        NestedChildMappingsSpec::ManifestResponseFont.new(
+          name: "Yu Gothic",
+          styles: [
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Yu Gothic Bold",
+              type: "Bold",
+              paths: [
+                "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothB.ttc",
+              ],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Yu Gothic Regular",
+              type: "Regular",
+              paths: [
+                "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothR.ttc",
+              ],
+            ),
+          ],
+        ),
+        NestedChildMappingsSpec::ManifestResponseFont.new(
+          name: "Noto Sans Condensed",
+          styles: [
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed",
+              type: "Regular",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-Condensed.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Bold",
+              type: "Bold",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedBold.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Bold Italic",
+              type: "Bold Italic",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedBoldItalic.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Italic",
+              type: "Italic",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedItalic.ttf"],
+            ),
+          ],
+        ),
+      ],
+    )
+  end
+
+  it "parses nested child mappings correctly" do
+    expect(parsed_yaml).to eq(expected_fonts)
+  end
+
+  it "rounds trip correctly" do
+    expected_yaml = parsed_yaml.to_yaml
+    expect(expected_yaml).to eq(yaml)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-25 00:00:00.000000000 Z
+date: 2025-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moxml
@@ -367,6 +367,7 @@ files:
 - spec/lutaml/model/xml/derived_attributes_spec.rb
 - spec/lutaml/model/xml/namespace/nested_with_explicit_namespace_spec.rb
 - spec/lutaml/model/xml/namespace_spec.rb
+- spec/lutaml/model/xml/root_mappings/nested_child_mappings_spec.rb
 - spec/lutaml/model/xml/xml_element_spec.rb
 - spec/lutaml/model/xml_adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/model/xml_adapter/oga_adapter_spec.rb