lutaml-model 0.8.87 → 0.8.88

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86ca328809a1a0e065b430ec56f016fbe70ee892cf705ceb618a7d1869aa8d77
-  data.tar.gz: 5f23509351e875b5e43c459de66a134cb2d3106288528a43a9adfa97f411a2c6
+  metadata.gz: edd074b78dadf665677a6c6e7d738b7d409aa63e4bbef51c9a6b0a61d36a6454
+  data.tar.gz: 9b88edc42b0b865cc2ea3523a9d923f1b988980255508e31da22fb66c06e87fe
 SHA512:
-  metadata.gz: 8172239de2524442bca61fdfd9111f9163f8fd03b5b84f620a54940b22aab359a2e7d4ade1a127b651af717dbce2172b244670047ec9a1ff5890abce8ce5457d
-  data.tar.gz: 579e6c690fabd240ddb1ced902c38dee5af5d86bf3d0d2ecfd0c3ccf01749b62843f1189660579b193bca8edc1f1f127e8ccc1fbfaa5c0209d79b2fc8841bf23
+  metadata.gz: e90cbcc5a0046c0bd3b6d5e687fb6a9e137f3e9a8d63149296082cd468a747bec1690e5720b6a423b1a17bbe8706ce2773687671388aa303b68f3e2d37805e90
+  data.tar.gz: 163d5e386a27f6e6f4806096866de4f3005191acba9183929017c9292ecfae68fb066e6d19054102effb9eb8ed0118bc8e322d613f0cb5345183f16f328c6c02

data/bench/bench_common.rb

@@ -20,7 +20,7 @@ if ENV["PLAN_COMPILE_STATS"]
   at_exit do
     require "pp"
     puts "\nPlanCompiler opt-out histogram:"
-    pp(Lutaml::Xml::PlanCompiler.stats)
+    pp(Lutaml::Xml::Leptris::PlanCompiler.stats)
   end
 end
 require "benchmark"

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

@@ -8,7 +8,7 @@ module Lutaml
       # families that carry the feature override (KeyValue's
       # root_mappings, Xml's namespace_class); the base defaults make
       # the absence explicit instead of probed.
-      def root_mappings
+      def root_mappings?
         false
       end
 

data/lib/lutaml/model/serializable.rb

@@ -26,7 +26,8 @@ module Lutaml
         parts = (instance_variables - INSPECT_EXCLUDED_IVARS).map do |iv|
           "#{iv}=#{self.class.inspect_value(instance_variable_get(iv))}"
         end
-        "#<#{self.class.name}#{' ' + parts.join(', ') unless parts.empty?}>"
+        attrs = " #{parts.join(', ')}" unless parts.empty?
+        "#<#{self.class.name}#{attrs}>"
       end
 
       class << self

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -150,48 +150,41 @@ module Lutaml
         #
         # @return [Array<Class>] List of error classes
         def format_error_types
-          @format_error_types_base ||= begin
-            errors = [
-              Lutaml::Model::RuntimeCompatibility.safe_constantize("Psych::SyntaxError"),
-              Lutaml::Model::RuntimeCompatibility.safe_constantize("JSON::ParserError"),
-              NoMethodError,
-              TypeError,
-              ArgumentError,
-            ]
-
-            # Collect format-specific error types from FormatRegistry
-            compatibility = Lutaml::Model::RuntimeCompatibility
-            FormatRegistry.all.each_value do |info|
-              next unless info[:error_types]
-
-              info[:error_types].each do |error_class|
-                cls = if error_class.is_a?(String)
-                        compatibility.safe_constantize(error_class)
-                      else
-                        error_class
-                      end
-                errors << cls
-              end
+          # Resolved per call, not memoized: adapter engines load lazily,
+          # and a cache built before an engine loads permanently drops
+          # that engine's parse errors from the rescue list (an
+          # REXML::ParseException leaked un-wrapped when any earlier
+          # parse ran before rexml was required). The constantize pass
+          # is a handful of lookups — negligible against a parse.
+          compatibility = Lutaml::Model::RuntimeCompatibility
+          errors = [
+            compatibility.safe_constantize("Psych::SyntaxError"),
+            compatibility.safe_constantize("JSON::ParserError"),
+            NoMethodError,
+            TypeError,
+            ArgumentError,
+          ]
+
+          FormatRegistry.all.each_value do |info|
+            next unless info[:error_types]
+
+            info[:error_types].each do |error_class|
+              errors << if error_class.is_a?(String)
+                          compatibility.safe_constantize(error_class)
+                        else
+                          error_class
+                        end
             end
-
-            errors.compact.freeze
           end
 
           # Legacy TOML error types are lazy, so check them on each call.
-          compatibility = Lutaml::Model::RuntimeCompatibility
-          toml_errors = compatibility.safe_constantize("TomlRB::ParseError")
-          toml_errors = Array(toml_errors)
+          toml_errors = Array(compatibility.safe_constantize("TomlRB::ParseError"))
           tomllib_err = compatibility.safe_constantize("Tomlib::ParseError")
           toml_errors << tomllib_err if tomllib_err
           teptris_err = compatibility.safe_constantize("Teptris::ParseError")
           toml_errors << teptris_err if teptris_err
 
-          @format_error_types_base + toml_errors
-        end
-
-        # Reset cached error types (for test isolation)
-        def reset_format_error_types_cache!
-          @format_error_types_base = nil
+          (errors + toml_errors).compact
         end
 
         # Create a model instance from a parsed document

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.87"
+    VERSION = "0.8.88"
   end
 end

data/lib/lutaml/xml/leptris/plan_compiler.rb

@@ -285,7 +285,7 @@ module Lutaml
             # plan learns the catch-all row.
             return false if mapping.any_element_rule
 
-            mapping.root_element && !mapping.root_mappings
+            mapping.root_element && !mapping.root_mappings?
           end
 
           # Partition bookkeeping for when_attribute rows (#88, TODO

data/lib/lutaml/xml/mapping.rb

@@ -38,21 +38,7 @@ module Lutaml
         @xml_instance
       end
 
-      attr_reader :root_element,
-                  :namespace_uri,
-                  :namespace_prefix,
-                  :element_sequence,
-                  :mappings_imported,
-                  :namespace_class,
-                  :namespace_param,
-                  :element_name,
-                  :documentation_text,
-                  :type_name_value,
-                  :namespace_scope,
-                  :mapper_class,
-                  :xml_space,
-                  :consolidation_maps,
-                  :processing_instruction_mappings
+      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule
 
       def initialize
         super
@@ -523,8 +509,6 @@ module Lutaml
         @any_element_rule
       end
 
-      attr_reader :any_element_rule
-
       def map_instances(to:, polymorphic: {})
         map_element(to, to: to, polymorphic: polymorphic)
       end

data/lib/lutaml/xml/model_transform.rb

@@ -114,7 +114,14 @@ module Lutaml
           # Only needed for root elements (no lutaml_parent in options).
           # Three modes: :lazy (default), :eager, :skip.
           if !options.key?(:lutaml_parent)
-            plan_mode = options.fetch(:import_declaration_plan, :lazy)
+            # Default :eager — the plan data is tiny, but :lazy pins the
+            # adapter root element on every parsed instance, which keeps the
+            # entire native DOM (moxml wrappers + engine nodes) alive until
+            # first serialization. Models that are never serialized retain
+            # the DOM forever: a 10.5MB XMI held 578MB of wrappers this
+            # way. :lazy remains available for parse-serialize-immediately
+            # workflows that want to skip the namespace walk.
+            plan_mode = options.fetch(:import_declaration_plan, :eager)
             case plan_mode
             when :skip
               # Skip plan building entirely (fastest)
@@ -205,7 +212,9 @@ module Lutaml
             }
           end
 
-          result[path] = input_namespaces unless input_namespaces.empty?
+          # The path array is shared and mutated during the descent;
+          # snapshot it as a result key only where a declaration lives.
+          result[path.dup] = input_namespaces unless input_namespaces.empty?
         end
 
         # Recurse into children with path extended by child local name
@@ -223,8 +232,9 @@ module Lutaml
                              else
                                full_name
                              end
-          child_path = path + [child_local_name]
-          collect_element_namespaces(child, child_path, result, visited)
+          path.push(child_local_name)
+          collect_element_namespaces(child, path, result, visited)
+          path.pop
         end
 
         result

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

@@ -148,7 +148,8 @@ module Lutaml
           def target_namespace_from(model, value)
             model.target_namespace = value
             model.target_namespace_prefix =
-              namespace_prefix_for(model.pending_plan_root_element, value)
+              model.import_declaration_plan
+                &.global_prefix_registry&.[](value)
           end
 
           # Find a type definition by local name

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -67,7 +67,7 @@ module Lutaml
           # class method; a plain (non-Serializable) superclass ends
           # the chain.
           inherited = if superclass.is_a?(Class) &&
-                         superclass.include?(Lutaml::Model::Serialize)
+              superclass.include?(Lutaml::Model::Serialize)
                         superclass.xml_schema_paths
                       else
                         []

data/spec/lutaml/xml/clear_parse_state_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe "#clear_xml_parse_state!" do
     end
 
     it "clears pending_plan_root_element set by :lazy mode" do
-      model = model_class.from_xml(xml_with_ns)
+      model = model_class.from_xml(xml_with_ns, import_declaration_plan: :lazy)
       expect(model.pending_plan_root_element).not_to be_nil
       model.clear_xml_parse_state!
       expect(model.pending_plan_root_element).to be_nil

data/spec/lutaml/xml/doubly_defined_namespace_spec.rb

@@ -343,26 +343,30 @@ RSpec.describe "Doubly-defined namespace prefixes" do
       XML
     end
 
-    describe ":lazy (default)" do
+    describe ":lazy" do
       it "stores element reference for lazy plan building during parsing" do
-        model = model_class.from_xml(prefixed_xml)
+        model = model_class.from_xml(prefixed_xml,
+                                     import_declaration_plan: :lazy)
         expect(model.pending_plan_root_element).not_to be_nil
       end
 
       it "builds plan via import_declaration_plan method" do
-        model = model_class.from_xml(prefixed_xml)
+        model = model_class.from_xml(prefixed_xml,
+                                     import_declaration_plan: :lazy)
         expect(model.import_declaration_plan).to be_a(Lutaml::Xml::DeclarationPlan)
       end
 
       it "clears element reference after plan is built" do
-        model = model_class.from_xml(prefixed_xml)
+        model = model_class.from_xml(prefixed_xml,
+                                     import_declaration_plan: :lazy)
         expect(model.pending_plan_root_element).not_to be_nil
         _ = model.import_declaration_plan
         expect(model.pending_plan_root_element).to be_nil
       end
 
       it "imports plan automatically on to_xml" do
-        model = model_class.from_xml(prefixed_xml)
+        model = model_class.from_xml(prefixed_xml,
+                                     import_declaration_plan: :lazy)
         # Plan not yet built (instance variable is nil)
         expect(model.instance_variable_get(:@xml_declaration_plan)).to be_nil
         model.to_xml
@@ -371,12 +375,16 @@ RSpec.describe "Doubly-defined namespace prefixes" do
       end
     end
 
-    describe ":eager" do
+    describe ":eager (default)" do
       it "builds plan immediately during parsing" do
-        model = model_class.from_xml(prefixed_xml,
-                                     import_declaration_plan: :eager)
+        model = model_class.from_xml(prefixed_xml)
         expect(model.import_declaration_plan).to be_a(Lutaml::Xml::DeclarationPlan)
       end
+
+      it "does not retain the adapter root element" do
+        model = model_class.from_xml(prefixed_xml)
+        expect(model.pending_plan_root_element).to be_nil
+      end
     end
 
     describe ":skip" do

data/spec/lutaml/xml/parse_dom_retention_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML parse DOM retention" do
+  let(:model_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :item, :string
+
+      xml do
+        element "root"
+        map_element "item", to: :item
+      end
+    end
+  end
+
+  let(:xml) do
+    <<~XML
+      <root xmlns:xyz="http://example.com/items">
+        <xyz:item>hello</xyz:item>
+      </root>
+    XML
+  end
+
+  it "does not retain the adapter root element after parsing" do
+    model = model_class.from_xml(xml)
+    expect(model.pending_plan_root_element).to be_nil
+  end
+
+  it "still captures the input namespace declarations" do
+    model = model_class.from_xml(xml)
+    expect(model.import_declaration_plan).to be_a(Lutaml::Xml::DeclarationPlan)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.87
+  version: 0.8.88
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1977,6 +1977,7 @@ files:
 - spec/lutaml/xml/opal_xml_spec.rb
 - spec/lutaml/xml/ordered_method_spec.rb
 - spec/lutaml/xml/out_of_namespace_parsing_spec.rb
+- spec/lutaml/xml/parse_dom_retention_spec.rb
 - spec/lutaml/xml/pipeline_integration_spec.rb
 - spec/lutaml/xml/plain_model_accessors_spec.rb
 - spec/lutaml/xml/plan_fast_path_spec.rb