lutaml-model 0.8.64 → 0.8.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a6392d2dcfd63cc0cb61e585a164c72e09438c25154651cf9ad935e32985429
-  data.tar.gz: 492ad5dd9799652c1dd6abc9e148edba5937f3a613e143bdf556f625d94851fc
+  metadata.gz: f1a4f0f42471c24f887cb31b50be356825d1bb538ca568b30d15a703928c7d0b
+  data.tar.gz: b2b5227d2f505a10921d41123caf0f04b2cafec68ab0318db49690d394d1309a
 SHA512:
-  metadata.gz: c14bf78b03a2cce38a13d7a7c09cc07a7cca4b1dbed59a46c0faa9a5c4c275c872dcbff23afae3f8b8518b4fa926ad64597f0f7d67a7567a711ea05d60f8754d
-  data.tar.gz: c8d8b9723545747d826a7c16bb3d11699963299b2a238b5c04e5a724b1de555463fb839689cef9e46e52137c92a1f6831bd50676097653d888a92c57d7255f29
+  metadata.gz: 191a88d3dc8eacc1e94c8ea2b033500dbb4ce77345feefb6e7328527c4648c67575d10db7f9cb9e4d9611fada0902210077ae5c6ec0fcc4ff457b8637f35e2ef
+  data.tar.gz: fe6e34251e26d5593ec07873e5f0320a0802e0cd3c86ec89b8492c9add49c11f919dedd4aef225f6b8b63ca6564c0d3841f88d16b614fe265c8ebf3fb27fdb00

data/docs/_guides/native-engines.adoc

@@ -106,6 +106,13 @@ Lutaml::Model::Config.toml_adapter_type = :teptris
   raising `Psych::DisallowedClass`.
 * **JSON**: `yeptris` parsing targets exact `JSON.parse` semantics;
   generation stays on the `json` gem.
+* **Error classes**: parse failures keep the standard adapters' contract
+  on every engine — the yeptris adapters re-raise the engine's syntax
+  errors as `Psych::SyntaxError` (YAML, with the engine's line, column,
+  and problem text) and `JSON::ParserError` (JSON), and the model layer
+  wraps them as `InvalidFormatError` just as it does for Psych and the
+  `json` gem. Code that rescues those classes does not change when a
+  native engine is added to the bundle.
 * **TOML**: the teptris adapter mirrors tomlib value semantics — offset
   and local datetimes become `Time`, dates become `Date`, local times
   stay `String`. Parse failures raise `Teptris::ParseError` with line

data/lib/lutaml/json/adapter/yeptris_adapter.rb

@@ -12,9 +12,32 @@ module Lutaml
       # load-only), so everything else inherits from the standard adapter.
       class YeptrisAdapter < StandardAdapter
         def self.parse(json, _options = {})
-          require "yeptris"
+          require_engine
           ::Yeptris::JSON.load(json)
+        rescue ::Yeptris::JSON::ParseError => e
+          raise parser_error(e)
+        end
+
+        # The engine require sits outside parse's rescue so a broken
+        # install still surfaces its LoadError (the detection fallback's
+        # contract) instead of a NameError from the rescue clause.
+        def self.require_engine
+          require "yeptris"
+        end
+        private_class_method :require_engine
+
+        # The parse-error contract is the standard adapter's: invalid
+        # input raises JSON::ParserError regardless of the engine, so
+        # consumers' rescue ladders (and this gem's own
+        # format_error_types conversion to InvalidFormatError) hold on
+        # every adapter. Without the json gem the engine error
+        # propagates unchanged.
+        def self.parser_error(error)
+          return error unless defined?(::JSON::ParserError)
+
+          ::JSON::ParserError.new(error.message)
         end
+        private_class_method :parser_error
       end
     end
   end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.64"
+    VERSION = "0.8.66"
   end
 end

data/lib/lutaml/xml/plan_compiler.rb

@@ -36,6 +36,17 @@ module Lutaml
 
       class << self
         def compile(model_class, register)
+          # A child model's declared lutaml_default_register takes
+          # precedence over the ambient (parent) register — the same
+          # contract the interpretive path applies through
+          # Register.resolve_for_child. Without this, plan compilation
+          # resolves the child's symbol attribute types in the parent
+          # context and raises UnknownTypeError for ids registered only
+          # in the child's own register (#876).
+          register = Lutaml::Model::Register.resolve_for_child(
+            model_class, register
+          )
+
           key = [model_class, register]
           return PLAN_CACHE[key] if PLAN_CACHE.key?(key)
 

data/lib/lutaml/xml/plan_hydrator.rb

@@ -20,11 +20,21 @@ module Lutaml
         # node: the parsed source element (leptris); ordered/mixed
         #   plans rebuild element_order from it and ordered children
         #   hydrate natively against their own nodes
-        def call(model_class, plan, value, parent: nil, node: nil)
+        def call(model_class, plan, value, parent: nil, node: nil,
+                 register: nil)
+          # The child model's declared lutaml_default_register takes
+          # precedence over the ambient register — the same
+          # resolve_for_child contract the interpretive path applies.
+          # Without it, hydration resolves the child's symbol attribute
+          # types in the parent context and raises UnknownTypeError
+          # for ids registered only in the child's register (#876).
+          register = Lutaml::Model::Register.resolve_for_child(
+            model_class, register || Lutaml::Model::Config.default_register
+          )
           buckets = node && plan[:needs_nodes] ? element_buckets(node) : nil
           attr_kwargs = attributes_kwargs(plan, value, node)
           child_kwargs, children, delegates =
-            children_kwargs(model_class, plan, value, buckets)
+            children_kwargs(model_class, plan, value, buckets, register)
           plan[:collection_defaults].each do |name|
             next if attr_kwargs.key?(name) || child_kwargs.key?(name)
 
@@ -80,7 +90,9 @@ module Lutaml
         # — child instances come back so the caller can decorate
         # parent/root links once the parent exists; delegate values
         # wait for the instance (their target object must exist).
-        def children_kwargs(_model_class, plan, value, buckets = nil)
+        def children_kwargs(_model_class, plan, value, buckets = nil,
+                            register = nil)
+          register ||= Lutaml::Model::Config.default_register
           grouped, tagged = group_children(value, plan[:row_tags])
           buckets = nil unless buckets && plan[:needs_nodes]
           kwargs = {}
@@ -126,7 +138,8 @@ module Lutaml
                 child_plan = PlanCompiler.compile(child_type, register)
                 items = buckets.fetch(rule.name.to_s, []).map do |n|
                   call(child_type, child_plan,
-                       child_plan[:descriptor].walk(n), node: n)
+                       child_plan[:descriptor].walk(n), node: n,
+                                                        register: register)
                 end
                 unless items.empty?
                   children.concat(items)
@@ -162,7 +175,7 @@ module Lutaml
               items = grouped.fetch(rule.name.to_s, []).each_with_index
                 .map do |v, i|
                   call(child_type, child_plan, v,
-                       node: cursor && cursor[i])
+                       node: cursor && cursor[i], register: register)
                 end
               next if items.empty?
 

data/lib/lutaml/xml/plan_serializer.rb

@@ -25,16 +25,24 @@ module Lutaml
 
       class << self
         # plan: the compiler's entry for instance's class
-        def call(instance, plan)
+        def call(instance, plan, register = nil)
+          # The child model's declared lutaml_default_register takes
+          # precedence over the ambient register — the resolve_for_child
+          # contract (#876); without it, child plans and attribute
+          # serialization resolve in the parent context.
+          register = Lutaml::Model::Register.resolve_for_child(
+            instance.class,
+            register || Lutaml::Model::Config.default_register,
+          )
           return nil if plan[:ordered] && instance.element_order.nil?
 
           doc = ::Leptris::XML::Document.create
           root = doc.create_element(plan[:tree][:name])
           doc.root = root
           if plan[:ordered]
-            build_ordered(root, instance, plan, doc)
+            build_ordered(root, instance, plan, doc, register)
           else
-            build(root, instance, plan, doc)
+            build(root, instance, plan, doc, register)
           end
           doc.to_xml(indent: 2, no_decl: true)
         end
@@ -54,8 +62,9 @@ module Lutaml
           Lutaml::Model::Config.default_register
         end
 
-        def build(element, instance, plan, doc)
-          write_attributes(element, instance, plan)
+        def build(element, instance, plan, doc, reg = nil)
+          reg ||= register
+          write_attributes(element, instance, plan, reg)
           plan[:rows].each do |rule, attr, kind, spelling, delegate|
             value = value_of(instance, attr, delegate)
             next unless rule.render?(value, instance)
@@ -67,24 +76,25 @@ module Lutaml
               # as the interpretive writer does.
               Array(value).each do |item|
                 add_leaf(element, row_name(rule, spelling),
-                         attr.serialize(item, :xml, register), doc,
+                         attr.serialize(item, :xml, reg), doc,
                          attrs: rule.when_attribute)
               end
             when :collection_native, :collection_cb
               Array(value).each do |item|
                 add_leaf(element, rule.name.to_s,
-                         attr.serialize(item, :xml, register), doc,
+                         attr.serialize(item, :xml, reg), doc,
                          attrs: rule.when_attribute)
               end
             when :nested, :ordered_deferred
               Array(value).each do |item|
-                child_plan = PlanCompiler.compile(item.class, register)
+                child_plan = PlanCompiler.compile(item.class, reg)
                 child = element.create_child(child_plan[:tree][:name])
                 if child_plan[:ordered]
-                  return nil unless build_ordered(child, item, child_plan, doc)
+                  return nil unless build_ordered(child, item, child_plan,
+                                                  doc, reg)
 
                 else
-                  build(child, item, child_plan, doc)
+                  build(child, item, child_plan, doc, reg)
                 end
               end
             when :raw
@@ -103,8 +113,9 @@ module Lutaml
         # the model are reflected; element_order text is the fallback.
         # PIs drop (interpretive parity). Returns nil when a nested
         # ordered child lacks element_order (caller falls back).
-        def build_ordered(element, instance, plan, doc)
-          write_attributes(element, instance, plan)
+        def build_ordered(element, instance, plan, doc, reg = nil)
+          reg ||= register
+          write_attributes(element, instance, plan, reg)
           rows_by_name = {}
           plan[:rows].each do |rule, attr, kind, spelling, delegate|
             next unless rule.name
@@ -162,7 +173,7 @@ module Lutaml
 
                 element_indices[object.name] += 1
                 add_leaf(element, object.name,
-                         attr.serialize(items[index], :xml, register), doc)
+                         attr.serialize(items[index], :xml, reg), doc)
               when :nested, :ordered_deferred
                 item = if attr.collection?
                          index = element_indices[object.name]
@@ -173,18 +184,19 @@ module Lutaml
                        end
                 next unless item
 
-                child_plan = PlanCompiler.compile(item.class, register)
+                child_plan = PlanCompiler.compile(item.class, reg)
                 child = element.create_child(child_plan[:tree][:name])
                 if child_plan[:ordered]
-                  return nil unless build_ordered(child, item, child_plan, doc)
+                  return nil unless build_ordered(child, item, child_plan,
+                                                  doc, reg)
                 else
-                  build(child, item, child_plan, doc)
+                  build(child, item, child_plan, doc, reg)
                 end
               when :raw
                 element.add_child(value.to_s) unless value.nil?
               when :scalar
                 add_leaf(element, object.name,
-                         attr.serialize(value, :xml, register), doc)
+                         attr.serialize(value, :xml, reg), doc)
               end
             end
           end
@@ -193,7 +205,7 @@ module Lutaml
 
         # Attributes in document order when the instance recorded it
         # (parsed models), else plan row order.
-        def write_attributes(element, instance, plan)
+        def write_attributes(element, instance, plan, _reg = nil)
           recorded = instance.attribute_order
           if recorded && !recorded.empty?
             by_name = {}
@@ -213,7 +225,7 @@ module Lutaml
           end
         end
 
-        def write_attribute(element, instance, name, entry)
+        def write_attribute(element, instance, name, entry, reg = nil)
           return unless entry
 
           _rule, attr, delegate = entry
@@ -221,7 +233,7 @@ module Lutaml
           return if value.nil?
 
           element.set_attribute(name,
-                                attr.serialize(value, :xml, register).to_s)
+                                attr.serialize(value, :xml, reg || register).to_s)
         end
 
         # Partition rows (#88) re-emit their discriminator: the wire

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -14,18 +14,50 @@ module Lutaml
       # Semantic notes vs the standard adapter's Psych.safe_load:
       # implicit typing is parity-verified (compat_11 schema); anchors
       # and aliases always resolve; a tagged value without a core type
-      # materializes as plain data instead of raising DisallowedClass.
+      # materializes as plain data instead of raising DisallowedClass;
+      # parse failures surface as Psych::SyntaxError like the standard
+      # adapter's (the engine's own ParseError is re-raised under the
+      # standard class).
       class YeptrisAdapter < StandardAdapter
         # yeptris is required lazily: the ruby-platform variant installs
         # everywhere but only loads where libyeptris exists (no Windows
         # prebuilts) — a broken install must degrade to detection
         # fallback, never crash loads.
         def self.parse(yaml, _options = {})
-          require "yeptris"
+          require_engine
           require "yeptris/yaml"
           # rubocop:disable-next Naming/VariableNumber -- upstream schema literal
           Yeptris::YAML.load(yaml, schema: :compat_11)
+        rescue Yeptris::ParseError => e
+          raise syntax_error(e)
+        end
+
+        # The engine require sits outside parse's rescue so a broken
+        # install still surfaces its LoadError (the detection fallback's
+        # contract) instead of a NameError from the rescue clause.
+        def self.require_engine
+          require "yeptris"
+        end
+        private_class_method :require_engine
+
+        # The parse-error contract is the standard adapter's: invalid
+        # input raises Psych::SyntaxError regardless of the engine, so
+        # consumers' rescue ladders (and this gem's own
+        # format_error_types conversion to InvalidFormatError) hold on
+        # every adapter. The C parser reports the position inside the
+        # error message ("... at line L, column C"); lift it into the
+        # structured fields. Without psych (Opal) the engine error
+        # propagates unchanged.
+        def self.syntax_error(error)
+          return error unless defined?(::Psych::SyntaxError)
+
+          match = /\bline (\d+),? column (\d+)/.match(error.message)
+          line = match ? match[1].to_i : 0
+          column = match ? match[2].to_i : 0
+          problem = error.message.sub(/\s+at\s+line\s+\d+,?\s+column\s+\d+\z/, "")
+          ::Psych::SyntaxError.new(nil, line, column, 0, problem, nil)
         end
+        private_class_method :syntax_error
 
         def to_yaml(_options = {})
           attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)

data/spec/lutaml/json/yeptris_adapter_spec.rb

@@ -25,9 +25,9 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Json::Adapter::YeptrisAdapter : Objec
         .to eq("a" => 1.5, "b" => nil, "c" => true, "d" => "1e3")
     end
 
-    it "raises on invalid JSON" do
+    it "raises JSON::ParserError on invalid JSON, like the standard adapter" do
       expect { described_class.parse("{nope") }
-        .to raise_error(Yeptris::JSON::ParseError)
+        .to raise_error(JSON::ParserError)
     end
   end
 
@@ -59,5 +59,10 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Json::Adapter::YeptrisAdapter : Objec
       expect(model.roles).to eq(%w[admin dev])
       expect(model_class.from_json(model.to_json).roles).to eq(%w[admin dev])
     end
+
+    it "surfaces invalid JSON as InvalidFormatError" do
+      expect { model_class.from_json("{nope") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
   end
 end

data/spec/lutaml/model/yeptris_error_parity_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "open3"
+require "spec_helper"
+
+# The suite deliberately never loads the optional yeptris engine
+# in-process (adapter_resolver_configured_spec asserts the resolver's
+# lazy-detection guarantee), so the error-class contract is exercised
+# in a subprocess: wherever the engine is installed it is the
+# preferred adapter, and its parse failures must surface under the
+# standard adapters' error classes — Psych::SyntaxError and
+# JSON::ParserError from the adapters, Lutaml::Model::InvalidFormatError
+# through a model — so downstream rescue ladders hold on every engine.
+RSpec.describe "yeptris adapter error parity" do
+  # A direct ruby invocation with explicit load paths and NO shell:
+  # a nested `bundle exec` produced empty output on some CI legs, and
+  # backticks route through cmd.exe on Windows where POSIX quoting
+  # mangles the command. Open3 with array arguments is shell-free on
+  # every platform.
+  subject(:outcomes) do
+    libs = %w[lutaml-model yeptris yeptris-ruby moxml leptris].filter_map do |g|
+      "#{Gem::Specification.find_by_name(g).gem_dir}/lib"
+    rescue Gem::LoadError
+      nil
+    end
+    args = libs.flat_map { |l| ["-I", l] } + ["-e", probe]
+    Open3.capture2e(Gem.ruby, *args).first
+  end
+
+  def yeptris_installed?
+    Gem::Specification.find_by_name("yeptris")
+    true
+  rescue Gem::LoadError
+    false
+  end
+
+  # The probe requires the engine explicitly (the resolved adapters
+  # prove the preference), then reports one outcome line per surface.
+  let(:probe) do
+    <<~RUBY
+      require "lutaml/model"
+
+      def outcome
+        yield
+        "NO-ERROR"
+      rescue StandardError => e
+        "\#{e.class.name}: \#{e.message}"
+      end
+
+      puts "yaml-adapter: \#{Lutaml::Model::AdapterResolver.adapter_for(:yaml).name}"
+      puts "json-adapter: \#{Lutaml::Model::AdapterResolver.adapter_for(:json).name}"
+
+      puts "adapter-yaml: \#{outcome do
+        Lutaml::Yaml::Adapter::YeptrisAdapter.parse("name: test\\n  invalid: [unclosed\\n")
+      end }"
+      puts "adapter-json: \#{outcome do
+        Lutaml::Json::Adapter::YeptrisAdapter.parse("{nope")
+      end }"
+
+      model_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        key_value { map "name", to: :name }
+      end
+      puts "model-yaml: \#{outcome do
+        model_class.from_yaml("name: test\\n  invalid: [unclosed\\n")
+      end }"
+      puts "model-json: \#{outcome do
+        model_class.from_json("{nope")
+      end }"
+    RUBY
+  end
+
+  before { skip "yeptris is not installed" unless yeptris_installed? }
+
+  it "prefers the yeptris adapters when the engine is installed" do
+    expect(outcomes).to include("yaml-adapter: Lutaml::Yaml::Adapter::YeptrisAdapter")
+    expect(outcomes).to include("json-adapter: Lutaml::Json::Adapter::YeptrisAdapter")
+  end
+
+  it "raises Psych::SyntaxError from the yaml adapter for invalid YAML" do
+    expect(outcomes).to match(/^adapter-yaml: Psych::SyntaxError: .+ at line \d+/)
+  end
+
+  it "raises JSON::ParserError from the json adapter for invalid JSON" do
+    expect(outcomes).to match(/^adapter-json: JSON::ParserError: /)
+  end
+
+  it "raises InvalidFormatError through a model for invalid YAML" do
+    expect(outcomes).to match(/^model-yaml: Lutaml::Model::InvalidFormatError: /)
+  end
+
+  it "raises InvalidFormatError through a model for invalid JSON" do
+    expect(outcomes).to match(/^model-json: Lutaml::Model::InvalidFormatError: /)
+  end
+end

data/spec/lutaml/xml/cross_register_plan_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Cross-register embedding on the plan paths (#876)" do
+  before do
+    stub_const("CrossRegister876", Module.new)
+    stub_const("CrossRegister876::Part", part_class)
+    stub_const("CrossRegister876::Widget", widget_class)
+    stub_const("Host876", host_class)
+
+    ctx = Lutaml::Model::GlobalContext.create_context(
+      id: :crossregister876, registry: Lutaml::Model::TypeRegistry.new,
+    )
+    ctx.registry.register(:part, CrossRegister876::Part)
+    ctx.registry.register(:widget, CrossRegister876::Widget)
+  end
+
+  let(:part_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      def self.lutaml_default_register
+        :crossregister876
+      end
+
+      xml do
+        element "part"
+      end
+    end
+  end
+
+  let(:widget_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      def self.lutaml_default_register
+        :crossregister876
+      end
+
+      attribute :part_value, :part, collection: true
+
+      xml do
+        element "widget"
+        ordered
+        map_element "part", to: :part_value
+      end
+    end
+    klass
+  end
+
+  let(:host_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :widget, CrossRegister876::Widget
+
+      xml do
+        element "host"
+        map_element "widget", to: :widget
+      end
+    end
+  end
+
+  let(:xml) { "<host><widget><part/></widget></host>" }
+
+  it "resolves the child's symbol types through the child register" do
+    model = Host876.from_xml(xml)
+    expect(model.widget.part_value.first).to be_a(CrossRegister876::Part)
+  end
+
+  it "round-trips through both the plan serializer and back" do
+    model = Host876.from_xml(xml)
+    xml_out = model.to_xml
+    expect(xml_out).to include("<widget>")
+    expect(xml_out).to include("<part/>")
+
+    reparsed = Host876.from_xml(xml_out)
+    expect(reparsed.widget.part_value.first).to be_a(CrossRegister876::Part)
+  end
+end

data/spec/lutaml/yaml/yeptris_adapter_spec.rb

@@ -30,6 +30,30 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(described_class.parse("d: 2020-01-01\n"))
         .to eq("d" => Date.new(2020, 1, 1))
     end
+
+    it "raises Psych::SyntaxError for invalid YAML, like the standard adapter" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "raises Psych::SyntaxError for a mapping value inside a plain scalar" do
+      # The dependent-CI shape: one line, a second "key:" colon after a
+      # plain scalar run. Psych rejects it with "mapping values are not
+      # allowed in this context"; the engine must surface under the
+      # same class so downstream rescue ladders hold.
+      expect { described_class.parse('name: test\n  invalid: [unclosed') }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "carries the engine's position on the syntax error" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError) do |error|
+        expect(error.line).to be >= 1
+        expect(error.problem).to be_a(String)
+        expect(error.problem).not_to be_empty
+        expect(error.message).to include("at line #{error.line}")
+      end
+    end
   end
 
   describe "#to_yaml" do
@@ -59,5 +83,10 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(model.roles).to eq(%w[admin dev])
       expect(model_class.from_yaml(model.to_yaml).roles).to eq(%w[admin dev])
     end
+
+    it "surfaces invalid YAML as InvalidFormatError" do
+      expect { model_class.from_yaml("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.64
+  version: 0.8.66
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1880,6 +1880,7 @@ files:
 - spec/lutaml/model/yamls_range_spec.rb
 - spec/lutaml/model/yamls_sequence_spec.rb
 - spec/lutaml/model/yamls_spec.rb
+- spec/lutaml/model/yeptris_error_parity_spec.rb
 - spec/lutaml/model_spec.rb
 - spec/lutaml/rdf/context_spec.rb
 - spec/lutaml/rdf/graph_serialization_spec.rb
@@ -1916,6 +1917,7 @@ files:
 - spec/lutaml/xml/conformance/xml_schema_instance_spec.rb
 - spec/lutaml/xml/content_model_validation_spec.rb
 - spec/lutaml/xml/cross_class_dispatch_spec.rb
+- spec/lutaml/xml/cross_register_plan_spec.rb
 - spec/lutaml/xml/data_model_spec.rb
 - spec/lutaml/xml/decisions/decision_engine_spec.rb
 - spec/lutaml/xml/decisions/decision_spec.rb