lutaml-model 0.8.126 → 0.8.128

data/lib/lutaml/xml/model_transform.rb

@@ -249,7 +249,9 @@ module Lutaml
         # Check if model class has a pre-compiled transformation
         model_class = model.class
         if model_class.is_a?(Class) && model_class.include?(::Lutaml::Model::Serialize)
-          transformation = model_class.transformation_for(:xml, lutaml_register)
+          transformation = model_class.transformation_for(
+            :xml, lutaml_register, mapping: @lutaml_mapping_override
+          )
 
           # If transformation exists and is an Xml::Transformation, use it
           if transformation.is_a?(::Lutaml::Xml::Transformation)
@@ -271,11 +273,13 @@ module Lutaml
         instance_is_serialize = session.instance_is_serialize
 
         # Performance: Resolve xml_mapping once — used for both rules and metadata
-        xml_mapping = mappings_for(:xml, effective_register)
-        mappings = options[:mappings] || xml_mapping.mappings(effective_register)
+        # An explicit mapping (#176 profiles) governs the rules and the
+        # metadata alike; its own catch-all rule applies.
+        xml_mapping = options[:mappings] || mappings_for(:xml, effective_register)
+        mappings = xml_mapping.mappings(effective_register)
         # Catch-all rule (map_any_element): iterated like any other,
         # claiming every child no explicit rule matches.
-        mappings += [xml_mapping.any_element_rule].compact if options[:mappings].nil?
+        mappings += [xml_mapping.any_element_rule].compact
         default_namespace = options[:default_namespace]
         ordered_option = options[:ordered]
         mixed_content_option = options[:mixed_content]

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -87,7 +87,14 @@ module Lutaml
 
         def self.generate(klass, options = {})
           register = extract_register_from(klass)
-          xml_mapping = klass.mappings_for(:xml)
+          # A mapping profile (#176) generates the schema of its own
+          # projection; the base mapping remains the default.
+          xml_mapping = if options[:mapping]
+                          klass.serialization_mapping_for(:xml,
+                                                          options[:mapping])
+                        else
+                          klass.mappings_for(:xml)
+                        end
 
           # Validate XSD types unless explicitly skipped
           validate_xsd_types!(klass, register) unless options[:skip_validation]
@@ -237,21 +244,29 @@ module Lutaml
             # Pattern 2: type_name only -> named complexType (no element)
             # Pattern 3: both element and type_name -> element + named complexType
 
+            # A mapping profile (#176) is a complete projection:
+            # attributes its mapping does not claim stay outside the
+            # generated schema.
+            skip_unmapped = !options[:mapping].nil?
+
             if element_name && type_name
               xs(xml, "element",
                  { name: element_name,
                    type: qualify_type_ref(type_name, target_prefix) })
               generate_complex_type(xml, klass, type_name, register,
-                                    xml_mapping, ctx: ctx)
+                                    xml_mapping, ctx: ctx,
+                                                 skip_unmapped: skip_unmapped)
             elsif type_name && !element_name
               generate_complex_type(xml, klass, type_name, register,
-                                    xml_mapping, ctx: ctx)
+                                    xml_mapping, ctx: ctx,
+                                                 skip_unmapped: skip_unmapped)
             else
               # Use class name as fallback element name if not specified
               elem_name = element_name || klass.name
               xs(xml, "element", { name: elem_name }) do
                 generate_complex_type_content(xml, klass, register, xml_mapping,
-                                              ctx: ctx)
+                                              ctx: ctx,
+                                              skip_unmapped: skip_unmapped)
               end
             end
 
@@ -491,11 +506,13 @@ module Lutaml
           attr.collection? && mapping&.type_name_value.nil?
         end
 
-        def self.generate_complex_type_content(xml, klass, register, xml_mapping, ctx:)
+        def self.generate_complex_type_content(xml, klass, register,
+xml_mapping, ctx:, skip_unmapped: false)
           xs(xml, "complexType") do
             if klass.attributes.any?
               xs(xml, "sequence") do
-                generate_elements(xml, klass, register, xml_mapping, ctx: ctx)
+                generate_elements(xml, klass, register, xml_mapping, ctx: ctx,
+                                                                     skip_unmapped: skip_unmapped)
               end
             end
             if xml_mapping
@@ -505,23 +522,27 @@ module Lutaml
           end
         end
 
-        def self.generate_complex_type(xml, klass, type_name, register, xml_mapping = nil, ctx:)
+        def self.generate_complex_type(xml, klass, type_name, register,
+xml_mapping = nil, ctx:, skip_unmapped: false)
           xs(xml, "complexType", { name: type_name }) do
             if klass.attributes.any?
               xs(xml, "sequence") do
-                generate_elements(xml, klass, register, xml_mapping, ctx: ctx)
+                generate_elements(xml, klass, register, xml_mapping, ctx: ctx,
+                                                                     skip_unmapped: skip_unmapped)
               end
             end
             generate_attributes(xml, klass, register, xml_mapping)
           end
         end
 
-        def self.generate_elements(xml, klass, register, xml_mapping, ctx:)
+        def self.generate_elements(xml, klass, register, xml_mapping, ctx:,
+skip_unmapped: false)
           klass.attributes.each do |name, attr|
             next if xml_mapping && attr_is_xml_attribute?(xml_mapping, name)
 
             # Find the mapping rule for this attribute
             mapping_rule = xml_mapping&.find_element(name)
+            next if skip_unmapped && xml_mapping && mapping_rule.nil?
 
             attr_type = attr.type(register)
 

data/lib/lutaml/xml/transformation.rb

@@ -28,8 +28,9 @@ module Lutaml
       # @param options [Hash] Transformation options
       # @return [::Lutaml::Xml::DataModel::XmlElement] The root XML element
       def transform(model_instance, options = {})
-        # Get root element name from mapping
-        mapping = model_class.mappings_for(:xml, register_id)
+        # Get root element name from mapping — an explicit mapping
+        # (#176 profiles) supplies its own root and root namespace.
+        mapping = options[:mappings] || model_class.mappings_for(:xml, register_id)
         root_name = options[:tag_name] ||
           mapping.root_element ||
           (model_class.name&.split("::")&.last || "anonymous")

data/spec/lutaml/key_value/child_map_plan_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Compiled child-map walk plans (#986b): child_mappings rules ride the
+# compiled dispatch (per-rule wire names, paths, and child type resolved
+# once) instead of the per-node interpretive translate_mappings. Parity
+# with the interpretive output is pinned here, including the
+# keys-only merge rule (the merge tests the whole document hash, not
+# each child) and the absent-key contract (the attribute stays
+# uninitialized).
+module ChildMapPlanSpec
+  class Schema < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :path, :string
+    attribute :name, :string
+  end
+
+  class Schemas < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :schemas, Schema, collection: true
+
+    key_value do
+      map "type", to: :type
+      map "schemas", to: :schemas,
+                     child_mappings: {
+                       id: :key,
+                       path: %i[path link],
+                       name: %i[path name],
+                     }
+    end
+  end
+
+  class Entry < Lutaml::Model::Serializable
+    attribute :key, :string
+    attribute :value, :string
+  end
+
+  class EntryList < Lutaml::Model::Serializable
+    attribute :title, :string
+    attribute :entries, Entry, collection: true
+
+    key_value do
+      map "title", to: :title
+      map "entries", to: :entries,
+                     child_mappings: {
+                       key: :key,
+                       value: %i[detail text],
+                     }
+    end
+  end
+
+  class Tag < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :count, :integer
+  end
+
+  class Tags < Lutaml::Model::Serializable
+    attribute :tags, Tag, collection: true
+
+    key_value do
+      map "tags", to: :tags,
+                  child_mappings: {
+                    name: :key,
+                    count: :value,
+                  }
+    end
+  end
+
+  class KeyedChild < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :label, :string
+    attribute :extra, :hash
+
+    key_value do
+      map "id", to: :id
+      map "label", to: :label
+      map_unmapped to: :extra
+    end
+  end
+
+  class KeyOnly < Lutaml::Model::Serializable
+    attribute :items, KeyedChild, collection: true
+
+    key_value do
+      map "items", to: :items,
+                   child_mappings: { id: :key }
+    end
+  end
+
+  RSpec.describe "compiled child_mappings walk plans" do
+    it "translates explicit-path child mappings into child models" do
+      model = Schemas.from_json(
+        '{"type":"object","schemas":{' \
+        '"sch1":{"path":{"link":"https://one","name":"one"}},' \
+        '"sch2":{"path":{"link":"https://two","name":"two"}}}}',
+      )
+
+      expect(model.schemas.map(&:id)).to eq(%w[sch1 sch2])
+      expect(model.schemas.first.path).to eq("https://one")
+      expect(model.schemas.last.name).to eq("two")
+    end
+
+    it "round-trips the translated wire form" do
+      json = '{"type":"object","schemas":{' \
+             '"sch1":{"path":{"link":"https://one","name":"one"}}}}'
+      model = Schemas.from_json(json)
+
+      expect(model.to_json).to eq(json)
+      expect(model.to_json).to eq(json) # warm-plan second pass
+    end
+
+    it "translates value paths" do
+      model = EntryList.from_json(
+        '{"title":"list","entries":{' \
+        '"e1":{"detail":{"text":"first"}},' \
+        '"e2":{"detail":{"text":"second"}}}}',
+      )
+
+      expect(model.entries.map(&:key)).to eq(%w[e1 e2])
+      expect(model.entries.first.value).to eq("first")
+    end
+
+    it "casts values through the child attribute types" do
+      model = Tags.from_json('{"tags":{"red":3,"blue":5}}')
+
+      expect(model.tags.map(&:name)).to eq(%w[red blue])
+      expect(model.tags.map(&:count)).to eq([3, 5])
+    end
+
+    it "keeps the attribute uninitialized when the key is absent" do
+      model = Schemas.from_json('{"type":"object"}')
+
+      expect(model.type).to eq("object")
+      expect(model.schemas).to be_nil
+    end
+
+    it "handles an empty mapping value" do
+      model = Schemas.from_json('{"type":"object","schemas":{}}')
+
+      expect(model.schemas).to eq([])
+    end
+
+    it "merges unmapped keys only when every value in the hash is a hash" do
+      model = KeyOnly.from_json(
+        '{"items":{"a":{"label":"A","extra":1},"b":{"label":"B"}}}',
+      )
+
+      expect(model.items.map(&:id)).to eq(%w[a b])
+      expect(model.items.first.label).to eq("A")
+      expect(model.items.first.extra).to eq("extra" => 1)
+    end
+
+    it "skips the merge when any value in the hash is not a hash" do
+      model = KeyOnly.from_json('{"items":{"a":"plain","b":{"label":"B"}}}')
+
+      expect(model.items.first.id).to eq("a")
+      expect(model.items.first.extra).to be_nil
+      expect(model.items.last.id).to eq("b")
+      expect(model.items.last.label).to be_nil
+    end
+
+    it "serializes a keyed collection through the compiled plan" do
+      model = Tags.from_json('{"tags":{"red":3}}')
+
+      expect(model.to_json).to eq('{"tags":{"red":3}}')
+    end
+  end
+end

data/spec/lutaml/model/metaschema_types_spec.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The NIST Metaschema simple data types (#107), per
+# metaschema-datatypes.xsd and the sample values on
+# pages.nist.gov/metaschema/specification/datatypes/.
+RSpec.describe "NIST Metaschema simple data types" do
+  describe Lutaml::Model::Type::EmailAddress do
+    it "accepts addresses with an at-sign" do
+      expect(described_class.valid?("mailbox@example.com")).to be(true)
+      expect(described_class.cast("mailbox@example.com")).to eq("mailbox@example.com")
+    end
+
+    it "rejects strings without an at-sign" do
+      expect(described_class.valid?("mailbox.example.com")).to be(false)
+      expect(described_class.valid?("")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::Hostname do
+    it "accepts non-empty trimmed strings" do
+      expect(described_class.valid?("example.com")).to be(true)
+      expect(described_class.valid?("localhost")).to be(true)
+    end
+
+    it "rejects empty and outer-whitespace values" do
+      expect(described_class.valid?("")).to be(false)
+      expect(described_class.valid?(" example.com ")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::IpV4Address do
+    it "accepts dotted-quad addresses" do
+      expect(described_class.valid?("192.168.0.1")).to be(true)
+      expect(described_class.valid?("0.0.0.0")).to be(true)
+      expect(described_class.valid?("255.255.255.255")).to be(true)
+    end
+
+    it "rejects out-of-range octets and malformed forms" do
+      expect(described_class.valid?("256.0.0.1")).to be(false)
+      expect(described_class.valid?("192.168.0")).to be(false)
+      expect(described_class.valid?("192.168.0.1.5")).to be(false)
+      expect(described_class.valid?("example.com")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::IpV6Address do
+    it "accepts full and compressed forms" do
+      expect(described_class.valid?("2001:db8:0:0:0:0:2:1")).to be(true)
+      expect(described_class.valid?("2001:db8::2:1")).to be(true)
+      expect(described_class.valid?("::1")).to be(true)
+      expect(described_class.valid?("::")).to be(true)
+      expect(described_class.valid?("fe80::1%eth0")).to be(true)
+      expect(described_class.valid?("::ffff:192.168.0.1")).to be(true)
+    end
+
+    it "rejects malformed forms" do
+      expect(described_class.valid?("2001:db8:::1")).to be(false)
+      expect(described_class.valid?("192.168.0.1")).to be(false)
+      expect(described_class.valid?("2001:db8:0:0:0:0:2")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::Token do
+    it "accepts letters, digits, underscore and .-_ runs" do
+      expect(described_class.valid?("simple")).to be(true)
+      expect(described_class.valid?("_private.v2-final")).to be(true)
+      expect(described_class.valid?("label3")).to be(true)
+    end
+
+    it "rejects leading digits, spaces, and empty values" do
+      expect(described_class.valid?("3rd")).to be(false)
+      expect(described_class.valid?("with space")).to be(false)
+      expect(described_class.valid?("")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::UriReference do
+    it "accepts relative and absolute references" do
+      expect(described_class.valid?("#example")).to be(true)
+      expect(described_class.valid?("relative/path")).to be(true)
+      expect(described_class.valid?("https://example.com/x")).to be(true)
+    end
+
+    it "rejects empty and whitespace-padded values" do
+      expect(described_class.valid?("")).to be(false)
+      expect(described_class.valid?(" no ")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::Uuid do
+    it "accepts version 4 and 5 UUIDs" do
+      expect(described_class.valid?("a3bb189e-8bf9-4888-9912-ace4e6543002")).to be(true)
+      expect(described_class.valid?("5c0da4c0-6d4d-5e21-b0cd-3a5f9b1c9d01")).to be(true)
+    end
+
+    it "rejects other versions and malformed values" do
+      expect(described_class.valid?("a3bb189e-8bf9-1888-9912-ace4e6543002")).to be(false)
+      expect(described_class.valid?("a3bb189e-8bf9-4888-9912ace4e6543002")).to be(false)
+      expect(described_class.valid?("not-a-uuid")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::NonNegativeInteger do
+    it "accepts zero and positive integers" do
+      expect(described_class.valid?(0)).to be(true)
+      expect(described_class.valid?("42")).to be(true)
+      expect(described_class.cast("42")).to eq(42)
+    end
+
+    it "rejects negative values and non-integers" do
+      expect(described_class.valid?(-1)).to be(false)
+      expect(described_class.valid?("abc")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::PositiveInteger do
+    it "accepts integers of one and above" do
+      expect(described_class.valid?(1)).to be(true)
+      expect(described_class.valid?("7")).to be(true)
+    end
+
+    it "rejects zero, negatives, and non-integers" do
+      expect(described_class.valid?(0)).to be(false)
+      expect(described_class.valid?(-3)).to be(false)
+      expect(described_class.valid?("abc")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::DateWithTimezone do
+    it "accepts dates with Z or an offset, per the page samples" do
+      expect(described_class.valid?("2019-09-28Z")).to be(true)
+      expect(described_class.valid?("2019-12-02-08:00")).to be(true)
+    end
+
+    it "rejects dates without a timezone" do
+      expect(described_class.valid?("2019-09-28")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::DateTimeWithTimezone do
+    it "accepts date-times with Z or an offset, per the page samples" do
+      expect(described_class.valid?("2019-09-28T23:20:50.52Z")).to be(true)
+      expect(described_class.valid?("2019-12-02T16:39:57-08:00")).to be(true)
+      expect(described_class.valid?("2019-12-31T23:59:59Z")).to be(true)
+    end
+
+    it "rejects date-times without a timezone" do
+      expect(described_class.valid?("2019-09-28T23:20:50.52")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::DayTimeDuration do
+    it "accepts day and time durations, per the page samples" do
+      expect(described_class.valid?("P1DT12H45M")).to be(true)
+      expect(described_class.valid?("-PT3H")).to be(true)
+      expect(described_class.valid?("PT0S")).to be(true)
+      expect(described_class.valid?("P3D")).to be(true)
+      expect(described_class.valid?("PT2M30.5S")).to be(true)
+    end
+
+    it "rejects year and month components" do
+      expect(described_class.valid?("P1Y6M")).to be(false)
+      expect(described_class.valid?("P1DT")).to be(false)
+    end
+  end
+
+  describe Lutaml::Model::Type::YearMonthDuration do
+    it "accepts year and month durations, per the page samples" do
+      expect(described_class.valid?("P1Y6M")).to be(true)
+      expect(described_class.valid?("-P9M")).to be(true)
+      expect(described_class.valid?("P10M")).to be(true)
+      expect(described_class.valid?("P2Y")).to be(true)
+    end
+
+    it "rejects time components and bare days" do
+      expect(described_class.valid?("P1DT12H")).to be(false)
+      expect(described_class.valid?("P3D")).to be(false)
+    end
+  end
+
+  it "round-trips a metaschema-typed model through JSON" do
+    stub_const("MetaNode", Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :uuid
+      attribute :contact, :email_address
+      attribute :address, :ip_v4_address
+      attribute :retries, :non_negative_integer
+
+      json do
+        map "id", to: :id
+        map "contact", to: :contact
+        map "address", to: :address
+        map "retries", to: :retries
+      end
+    end)
+
+    model = MetaNode.from_json(
+      '{"id":"a3bb189e-8bf9-4888-9912-ace4e6543002",' \
+      '"contact":"ops@example.com","address":"10.0.0.7","retries":"3"}',
+    )
+
+    expect(model.id).to eq("a3bb189e-8bf9-4888-9912-ace4e6543002")
+    expect(model.contact).to eq("ops@example.com")
+    expect(model.address).to eq("10.0.0.7")
+    expect(model.retries).to eq(3)
+    expect(model.to_json).to eq(
+      '{"id":"a3bb189e-8bf9-4888-9912-ace4e6543002",' \
+      '"contact":"ops@example.com","address":"10.0.0.7","retries":3}',
+    )
+  end
+
+  it "declares the metaschema XSD bases for schema generation" do
+    expect(Lutaml::Model::Type::NonNegativeInteger.default_xsd_type)
+      .to eq("xs:nonNegativeInteger")
+    expect(Lutaml::Model::Type::PositiveInteger.default_xsd_type)
+      .to eq("xs:positiveInteger")
+    expect(Lutaml::Model::Type::DayTimeDuration.default_xsd_type)
+      .to eq("xs:dayTimeDuration")
+    expect(Lutaml::Model::Type::YearMonthDuration.default_xsd_type)
+      .to eq("xs:yearMonthDuration")
+    expect(Lutaml::Model::Type::Uuid.default_xsd_type).to eq("xs:string")
+  end
+
+  describe "wiring into validation and schema emission" do
+    it "declares the patterns and bounds as Layer-2 facets" do
+      expect(Lutaml::Model::Type::Uuid.facets[:pattern])
+        .to include(Lutaml::Model::Type::Uuid::PATTERN)
+      expect(Lutaml::Model::Type::NonNegativeInteger.facets[:min_inclusive])
+        .to eq(0)
+      expect(Lutaml::Model::Type::PositiveInteger.facets[:min_inclusive])
+        .to eq(1)
+    end
+
+    it "validates metaschema-typed attributes through model validation" do
+      stub_const("WiredNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :retries, :positive_integer
+
+        json do
+          map "id", to: :id
+          map "contact", to: :contact
+          map "retries", to: :retries
+        end
+      end)
+
+      good = WiredNode.new(id: "a3bb189e-8bf9-4888-9912-ace4e6543002",
+                           contact: "ops@example.com", retries: 2)
+      expect(good.validate).to be_empty
+
+      bad = WiredNode.new(id: "not-a-uuid", contact: "no-at-sign", retries: 0)
+      messages = bad.validate.map(&:message)
+
+      expect(messages).to all(be_a(String))
+      expect(messages.join("\n")).to include("id")
+      expect(messages.join("\n")).to include("contact")
+      expect(messages.join("\n")).to include("retries")
+    end
+
+    it "exports the metaschema restrictions in generated XSD" do
+      stub_const("XsdNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :retries, :positive_integer
+
+        xml do
+          element "node"
+          map_attribute "id", to: :id
+          map_element "contact", to: :contact
+          map_element "retries", to: :retries
+        end
+      end)
+
+      xsd = Lutaml::Model::Schema.to_xsd(XsdNode)
+
+      expect(xsd).to include("[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[45]")
+      expect(xsd).to include(".+@.+")
+      expect(xsd).to include('minInclusive value="1"')
+    end
+
+    it "exports the NIST JSON representations in generated JSON and YAML schemas" do
+      stub_const("JsonWiredNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :address, :ip_v4_address
+        attribute :retries, :positive_integer
+        attribute :term, :year_month_duration
+
+        json do
+          map "id", to: :id
+          map "contact", to: :contact
+          map "address", to: :address
+          map "retries", to: :retries
+          map "term", to: :term
+        end
+      end)
+
+      properties = JSON.parse(Lutaml::Model::Schema.to_json(JsonWiredNode))
+        .fetch("$defs").fetch("JsonWiredNode").fetch("properties")
+
+      expect(properties.fetch("id").fetch("pattern"))
+        .to eq("^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[45][0-9A-Fa-f]{3}-" \
+               "[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$")
+      expect(properties.fetch("contact")).to include("format" => "email")
+      expect(properties.fetch("address")).to include("format" => "ipv4")
+      expect(Array(properties.fetch("retries").fetch("type")))
+        .to include("integer")
+      expect(properties.fetch("retries")).to include("minimum" => 1)
+      expect(properties.fetch("term")).to include("format" => "duration")
+
+      yaml_properties = YAML.safe_load(
+        Lutaml::Model::Schema.to_yaml(JsonWiredNode),
+      ).fetch("$defs").fetch("JsonWiredNode").fetch("properties")
+
+      expect(yaml_properties.fetch("id")["pattern"]).to include("[45]")
+      expect(yaml_properties.fetch("retries")["minimum"]).to eq(1)
+    end
+
+    it "round-trips metaschema-typed models through every format" do
+      stub_const("FormatNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :host, :hostname
+        attribute :address, :ip_v4_address
+        attribute :renewal, :year_month_duration
+
+        xml do
+          element "node"
+          map_attribute "id", to: :id
+          map_element "host", to: :host
+          map_element "address", to: :address
+          map_element "renewal", to: :renewal
+        end
+
+        json do
+          map "id", to: :id
+          map "host", to: :host
+          map "address", to: :address
+          map "renewal", to: :renewal
+        end
+      end)
+
+      node = FormatNode.new(id: "a3bb189e-8bf9-4888-9912-ace4e6543002",
+                            host: "example.com", address: "10.0.0.7",
+                            renewal: "P1Y6M")
+
+      xml_round_trip = FormatNode.from_xml(node.to_xml)
+      expect(xml_round_trip).to eq(node)
+
+      json_round_trip = FormatNode.from_json(node.to_json)
+      expect(json_round_trip).to eq(node)
+
+      yaml_round_trip = FormatNode.from_yaml(node.to_yaml)
+      expect(yaml_round_trip).to eq(node)
+
+      toml_round_trip = FormatNode.from_toml(node.to_toml)
+      expect(toml_round_trip).to eq(node)
+    end
+
+    it "keeps the metaschema pattern sources export-clean" do
+      [Lutaml::Model::Type::IpV6Address,
+       Lutaml::Model::Type::DayTimeDuration].each do |type|
+        expect(type::PATTERN.source).not_to match(/\s/)
+      end
+    end
+  end
+end