lutaml-model 0.7.5 → 0.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99264c5157019d0cddfc59098e9603152db0a2d84caa8c9710a9c6a165f39cc4
-  data.tar.gz: 34886a6307aa6b6bb2211925477272c7a1412b67c7ef6695ea495a211bc0e540
+  metadata.gz: 518cf7f42227fbdd75f25ed97d2107f0d0c575290ae2a21d5be323b70546cae4
+  data.tar.gz: 19f355abc4da8bff1ce95b06eba36aca987888325175aba9ab153998bcc8d68f
 SHA512:
-  metadata.gz: f1f358820c85b0626fade2aaac1ff1c3a408c0e267e22b25165d133b92adccbf31c2ca969099dbd441c1fbfc8d9833e5b1ff43fcdf079f6523e769f28bef91c5
-  data.tar.gz: c2799042e4d91fedd894c7f86c34f79ecc93509e4422b5f204aef1f5eb5150133e120fa442477c39185c210fe65c6fcb844bb6764e3833a6828235a4e9551054
+  metadata.gz: 9fb8b93ce570cc804f4f9d2f1562ac58dab5b76aa55b5d3b79d82a95eef6edc4c65752beeb7d6176878d4f765dbf40a3f63331b8b2b726363b7a5a506046d243
+  data.tar.gz: 10a50c4c30cf2034d3e394fd8526d00c220df5dcf216d8dd5fc19395858766254d8e8f835232404be2661d5821ebb05e82afad130b238d27aa224d5fc38855cd

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

@@ -4,6 +4,24 @@ module Lutaml
       include Enumerable
 
       class << self
+        INHERITED_ATTRIBUTES = %i[
+          instance_type
+          instance_name
+          order_by_field
+          order_direction
+        ].freeze
+
+        def inherited(subclass)
+          super
+
+          INHERITED_ATTRIBUTES.each do |var|
+            subclass.instance_variable_set(
+              :"@#{var}",
+              instance_variable_get(:"@#{var}"),
+            )
+          end
+        end
+
         attr_reader :instance_type,
                     :instance_name,
                     :order_by_field,
@@ -87,23 +105,23 @@ 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)
-        type = register_object.get_class_without_register(self.class.instance_type)
+        register_object = Lutaml::Model::GlobalRegister.lookup(@__register)
+        type = register_object.get_class(self.class.instance_type)
         self.collection = items.map do |item|
           if item.is_a?(type)
             item
           elsif type <= Lutaml::Model::Type::Value
             type.cast(item)
           else
-            type.new(item, register: register)
+            type.new(item)
           end
         end
 

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

@@ -4,11 +4,11 @@ require_relative "key_value_mapping_rule"
 module Lutaml
   module Model
     class KeyValueMapping < Mapping
-      attr_reader :mappings, :format, :key_mappings, :value_mappings
+      attr_reader :format, :key_mappings, :value_mappings
 
       def initialize(format = nil)
         super()
-
+        @mappings = {}
         @format = format
       end
 
@@ -49,7 +49,7 @@ module Lutaml
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with, render_nil, render_empty)
 
-        @mappings << KeyValueMappingRule.new(
+        @mappings[mapping_name] = KeyValueMappingRule.new(
           mapping_name,
           to: to,
           render_nil: render_nil,
@@ -80,7 +80,7 @@ module Lutaml
       )
         @raw_mapping = true
         validate!(Constants::RAW_MAPPING_KEY, to, with, render_nil, nil)
-        @mappings << KeyValueMappingRule.new(
+        @mappings[Constants::RAW_MAPPING_KEY] = KeyValueMappingRule.new(
           Constants::RAW_MAPPING_KEY,
           to: to,
           render_nil: render_nil,
@@ -131,6 +131,14 @@ module Lutaml
         name
       end
 
+      def mappings
+        @mappings.values
+      end
+
+      def mappings_hash
+        @mappings
+      end
+
       def validate!(key, to, with, render_nil, render_empty)
         validate_mappings!(key)
         validate_to_and_with_arguments!(key, to, with)
@@ -178,7 +186,7 @@ module Lutaml
 
       def validate_mappings!(_type)
         if (@raw_mapping && Utils.present?(@mappings)) ||
-            (!@raw_mapping && @mappings.any?(&:raw_mapping?))
+            (!@raw_mapping && mappings.any?(&:raw_mapping?))
           raise StandardError, "map_all is not allowed with other mappings"
         end
       end
@@ -190,11 +198,11 @@ module Lutaml
       end
 
       def duplicate_mappings
-        @mappings.map(&:deep_dup)
+        Utils.deep_dup(@mappings)
       end
 
       def find_by_to(to)
-        @mappings.find { |m| m.to.to_s == to.to_s }
+        mappings.find { |m| m.to.to_s == to.to_s }
       end
 
       def find_by_name(name)
@@ -202,11 +210,11 @@ module Lutaml
       end
 
       def polymorphic_mapping
-        @mappings.find(&:polymorphic_mapping?)
+        mappings.find(&:polymorphic_mapping?)
       end
 
       def root_mapping
-        @mappings.find(&:root_mapping?)
+        mappings.find(&:root_mapping?)
       end
 
       Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|

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

@@ -64,6 +64,7 @@ module Lutaml
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           child_mappings: Utils.deep_dup(child_mappings),
+          root_mappings: Utils.deep_dup(root_mappings),
           value_map: Utils.deep_dup(@value_map),
         )
       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/register.rb

@@ -28,7 +28,7 @@ module Lutaml
       def get_class(klass_name)
         expected_class = get_class_without_register(klass_name)
         if !(expected_class < Lutaml::Model::Type::Value)
-          expected_class.class_variable_set(:@@register, id)
+          expected_class.class_variable_set(:@@__register, id)
         end
         expected_class
       end

data/lib/lutaml/model/schema/shared_methods.rb

@@ -5,8 +5,8 @@ module Lutaml
     module Schema
       module SharedMethods
         def extract_register_from(klass)
-          register = if klass.class_variable_defined?(:@@register)
-                       klass.class_variable_get(:@@register)
+          register = if klass.class_variable_defined?(:@@__register)
+                       klass.class_variable_get(:@@__register)
                      end
 
           case register

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
@@ -211,14 +211,14 @@ module Lutaml
               @mappings[format].merge_mapping_elements(mapping)
               @mappings[format].merge_elements_sequence(mapping)
             else
-              @mappings[format].mappings.concat(mapping.mappings)
+              @mappings[format].mappings_hash.merge!(mapping.mappings_hash)
             end
           end
         end
 
         def handle_key_value_mappings(mapping, format)
           @mappings[format] ||= KeyValueMapping.new
-          @mappings[format].mappings.concat(mapping.mappings)
+          @mappings[format].mappings_hash.merge!(mapping.mappings_hash)
         end
 
         def import_model(model)
@@ -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,20 +485,20 @@ 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)
           if register
             register.is_a?(Lutaml::Model::Register) ? register.id : register
-          elsif class_variable_defined?(:@@register)
-            class_variable_get(:@@register)
+          elsif class_variable_defined?(:@@__register)
+            class_variable_get(:@@__register)
           else
             Lutaml::Model::Config.default_register
           end
@@ -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.7"
   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,217 @@
+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
+
+  class ManifestResponseWrap < ManifestResponse
+    # This class confirms the successful inhertiance of the `Collection` attribute.
+  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(:wrapped_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(:wrap_parsed_yaml) do
+    NestedChildMappingsSpec::ManifestResponseWrap.from_yaml(wrapped_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
+
+  it "round trips nested child mappings correctly with Wrap class" do
+    expected_yaml = wrap_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.7
 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