lutaml-model 0.8.56 → 0.8.106

data/lib/lutaml/xml/namespace_needs.rb

@@ -8,20 +8,45 @@ module Lutaml
     # This class maintains MECE responsibility: it only stores and organizes
     # namespace needs data. It does NOT make decisions or build XML.
     class NamespaceNeeds
-      attr_reader :namespaces, :children, :type_namespaces,
-                  :type_namespace_classes, :type_attribute_namespaces,
-                  :type_element_namespaces, :type_refs,
-                  :namespace_scope_configs
-
-      def initialize
-        @namespaces = {} # Hash<String, NamespaceUsage>
-        @children = {} # Hash<Symbol, NamespaceNeeds>
-        @type_namespaces = {} # Hash<Symbol, Class>
-        @type_namespace_classes = Set.new # Set<Class>
-        @type_attribute_namespaces = Set.new # Set<Class>
-        @type_element_namespaces = Set.new # Set<Class>
-        @type_refs = [] # Array<TypeNamespace::Reference>
-        @namespace_scope_configs = [] # Array<NamespaceScopeConfig>
+      # Lazy readers: leaf nodes never touch most containers; the
+      # eager 4-Sets + 3-Hashes + 2-Arrays was the serialize path's
+      # top allocation site (150k births per 200-paragraph to_xml).
+      # Readers get the frozen empty truth; writers build on first
+      # touch through the ensure_* helpers below.
+      EMPTY_HASH = {}.freeze
+      EMPTY_SET = ::Set.new.freeze
+      EMPTY_ARRAY = [].freeze
+
+      def namespaces
+        @namespaces || EMPTY_HASH
+      end
+
+      def children
+        @children || EMPTY_HASH
+      end
+
+      def type_namespaces
+        @type_namespaces || EMPTY_HASH
+      end
+
+      def type_namespace_classes
+        @type_namespace_classes || EMPTY_SET
+      end
+
+      def type_attribute_namespaces
+        @type_attribute_namespaces || EMPTY_SET
+      end
+
+      def type_element_namespaces
+        @type_element_namespaces || EMPTY_SET
+      end
+
+      def type_refs
+        @type_refs || EMPTY_ARRAY
+      end
+
+      def namespace_scope_configs
+        @namespace_scope_configs || EMPTY_ARRAY
       end
 
       # Add namespace usage for a specific namespace
@@ -32,29 +57,29 @@ module Lutaml
           raise ArgumentError, "Expected NamespaceUsage, got #{usage.class}"
         end
 
-        @namespaces[key] = usage
+        (@namespaces ||= {})[key] = usage
       end
 
       # Track a type namespace for a specific attribute
       # @param attr_name [Symbol] Attribute name
       # @param ns_class [Class] XmlNamespace class
       def add_type_namespace(attr_name, ns_class)
-        @type_namespaces[attr_name] = ns_class
-        @type_namespace_classes << ns_class
+        (@type_namespaces ||= {})[attr_name] = ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add type attribute namespace to tracking set
       # @param ns_class [Class] XmlNamespace class
       def add_type_attribute_namespace(ns_class)
-        @type_attribute_namespaces << ns_class
-        @type_namespace_classes << ns_class
+        (@type_attribute_namespaces ||= ::Set.new) << ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add type element namespace to tracking set
       # @param ns_class [Class] XmlNamespace class
       def add_type_element_namespace(ns_class)
-        @type_element_namespaces << ns_class
-        @type_namespace_classes << ns_class
+        (@type_element_namespaces ||= ::Set.new) << ns_class
+        (@type_namespace_classes ||= ::Set.new) << ns_class
       end
 
       # Add a type reference for lazy resolution
@@ -65,13 +90,13 @@ module Lutaml
                 "Expected TypeNamespace::Reference, got #{reference.class}"
         end
 
-        @type_refs << reference
+        (@type_refs ||= []) << reference
       end
 
       # Clear type references after resolution
       # Used by TypeNamespaceResolver to prevent reprocessing
       def clear_type_refs
-        @type_refs.clear
+        @type_refs&.clear
       end
 
       # Add namespace scope configuration
@@ -82,7 +107,7 @@ module Lutaml
                 "Expected NamespaceScopeConfig, got #{config.class}"
         end
 
-        @namespace_scope_configs << config
+        (@namespace_scope_configs ||= []) << config
       end
 
       # Add child needs
@@ -94,7 +119,7 @@ module Lutaml
                 "Expected NamespaceNeeds, got #{child_needs.class}"
         end
 
-        @children[name] = child_needs
+        (@children ||= {})[name] = child_needs
       end
 
       # Merge another NamespaceNeeds into this one
@@ -105,9 +130,9 @@ module Lutaml
           raise ArgumentError, "Expected NamespaceNeeds, got #{other.class}"
         end
 
-        # Merge namespaces
+        # Merge namespaces (build containers on first touch)
         other.namespaces.each do |key, usage|
-          if @namespaces.key?(key)
+          if (@namespaces ||= {}).key?(key)
             @namespaces[key].merge(usage)
           else
             @namespaces[key] = usage
@@ -116,7 +141,7 @@ module Lutaml
 
         # Merge children
         other.children.each do |name, child_needs|
-          if @children.key?(name)
+          if (@children ||= {}).key?(name)
             @children[name].merge(child_needs)
           else
             @children[name] = child_needs
@@ -124,17 +149,20 @@ module Lutaml
         end
 
         # Merge type namespaces
-        @type_namespaces.merge!(other.type_namespaces)
-        @type_namespace_classes.merge(other.type_namespace_classes)
-        @type_attribute_namespaces.merge(other.type_attribute_namespaces)
-        @type_element_namespaces.merge(other.type_element_namespaces)
+        (@type_namespaces ||= {}).merge!(other.type_namespaces)
+        (@type_namespace_classes ||= ::Set.new)
+          .merge(other.type_namespace_classes)
+        (@type_attribute_namespaces ||= ::Set.new)
+          .merge(other.type_attribute_namespaces)
+        (@type_element_namespaces ||= ::Set.new)
+          .merge(other.type_element_namespaces)
 
         # Merge type refs
-        @type_refs.concat(other.type_refs)
+        (@type_refs ||= []).concat(other.type_refs)
 
         # Merge namespace scope configs (avoiding duplicates)
         other.namespace_scope_configs.each do |config|
-          unless @namespace_scope_configs.any? do |c|
+          unless (@namespace_scope_configs ||= []).any? do |c|
             c.namespace_class == config.namespace_class
           end
             @namespace_scope_configs << config
@@ -147,32 +175,32 @@ module Lutaml
       # Check if needs are empty
       # @return [Boolean]
       def empty?
-        @namespaces.empty? &&
-          @children.empty? &&
-          @type_refs.empty? &&
-          @type_namespaces.empty? &&
-          @namespace_scope_configs.empty?
+        namespaces.empty? &&
+          children.empty? &&
+          type_refs.empty? &&
+          type_namespaces.empty? &&
+          namespace_scope_configs.empty?
       end
 
       # Get namespace usage by key
       # @param key [String] Namespace key
       # @return [NamespaceUsage, nil]
       def namespace(key)
-        @namespaces[key]
+        namespaces[key]
       end
 
       # Get child needs by name
       # @param name [Symbol] Child attribute name
       # @return [NamespaceNeeds, nil]
       def child(name)
-        @children[name]
+        children[name]
       end
 
       # Check if a namespace is in scope configuration
       # @param ns_class [Class] XmlNamespace class
       # @return [NamespaceScopeConfig, nil]
       def scope_config_for(ns_class)
-        @namespace_scope_configs.find do |config|
+        namespace_scope_configs.find do |config|
           config.namespace_class == ns_class
         end
       end
@@ -180,28 +208,28 @@ module Lutaml
       # Get all namespace classes (from usage and type namespaces)
       # @return [Set<Class>]
       def all_namespace_classes
-        namespace_classes = Set.new(@namespaces.values.map(&:namespace_class))
-        namespace_classes.merge(@type_namespace_classes)
+        classes = Set.new(namespaces.values.map(&:namespace_class))
+        classes.merge(type_namespace_classes)
       end
 
       # Validate internal consistency
       # @raise [RuntimeError] if inconsistent state detected
       def validate!
         # Type attribute and element namespaces should be mutually exclusive
-        overlap = @type_attribute_namespaces & @type_element_namespaces
+        overlap = type_attribute_namespaces & type_element_namespaces
         unless overlap.empty?
           raise "Type namespaces appear in both attribute and element contexts: #{overlap.to_a}"
         end
 
         # All type namespace classes should be in type_namespace_classes
-        @type_attribute_namespaces.each do |ns_class|
-          unless @type_namespace_classes.include?(ns_class)
+        type_attribute_namespaces.each do |ns_class|
+          unless type_namespace_classes.include?(ns_class)
             raise "Type attribute namespace #{ns_class} not in type_namespace_classes"
           end
         end
 
-        @type_element_namespaces.each do |ns_class|
-          unless @type_namespace_classes.include?(ns_class)
+        type_element_namespaces.each do |ns_class|
+          unless type_namespace_classes.include?(ns_class)
             raise "Type element namespace #{ns_class} not in type_namespace_classes"
           end
         end

data/lib/lutaml/xml/parse_session.rb

@@ -24,6 +24,10 @@ module Lutaml
         @instance_is_serialize ||= instance.is_a?(::Lutaml::Model::Serialize)
       end
 
+      def mapping
+        @mapping ||= instance.class.mappings_for(:xml, register)
+      end
+
       # (element, rule name) -> resolved attribute name / matched
       # attribute VALUE for the lenient lookup paths. Both are pure
       # functions of the element and the name; ISO-13849-shaped
@@ -80,25 +84,9 @@ module Lutaml
       # Empty unless the mapping uses when_attribute at all; non-Serialize
       # custom models have no mappings to partition.
       def when_attribute_partition
-        @when_attribute_partition ||=
-          if instance_is_serialize && (mapping = xml_mapping)
-            siblings = {}
-            plain_names = {}
-            mapping.mappings.each do |rule|
-              next if rule.attribute? || rule.content_mapping? ||
-                rule.raw_mapping? || rule.cdata
-
-              pairs = rule.when_attribute
-              if pairs && !pairs.empty?
-                (siblings[rule.name.to_s] ||= []) << rule
-              else
-                plain_names[rule.name.to_s] = true
-              end
-            end
-            [siblings, plain_names]
-          else
-            [{}, {}]
-          end
+        return [{}, {}] unless instance_is_serialize && (mapping = xml_mapping)
+
+        mapping.when_attribute_partition
       end
 
       def when_attribute_siblings_by_name

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

@@ -63,7 +63,11 @@ module Lutaml
         #
         # @return [Array<String>]
         def xml_schema_paths
-          inherited = if superclass.respond_to?(:xml_schema_paths)
+          # Type check, not a probe: every Serializable carries the
+          # class method; a plain (non-Serializable) superclass ends
+          # the chain.
+          inherited = if superclass.is_a?(Class) &&
+              superclass.include?(Lutaml::Model::Serialize)
                         superclass.xml_schema_paths
                       else
                         []

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -101,20 +101,26 @@ model_class, register_id)
             return
           end
 
-          # Extract parent's namespace info for element_form_default inheritance
-          parent_ns_class = parent.namespace_class
-          # Only pass element_form_default VALUE if it was explicitly set
-          # When not set (defaults to :unqualified), pass nil to avoid incorrect blank namespace treatment
-          parent_element_form_default = if parent_ns_class&.element_form_default_set?
-                                          parent_ns_class.element_form_default
-                                        end
-
-          # Merge parent context into options
-          child_options = options.merge(
-            parent_namespace_class: parent_ns_class,
-            parent_element_form_default: parent_element_form_default,
-            parent_element: parent,
-          )
+          # Fast path: the ordered walk pre-sets the parent context keys
+          # for every value it emits (one hash per walk, not per value).
+          # The three keys are always written together, so a parent
+          # identity match implies the namespace context matches too.
+          if options[:parent_element] == parent
+            child_options = options
+          else
+            parent_ns_class = parent.namespace_class
+            # Only pass element_form_default VALUE if it was explicitly set
+            # When not set (defaults to :unqualified), pass nil to avoid incorrect blank namespace treatment
+            parent_element_form_default = if parent_ns_class&.element_form_default_set?
+                                            parent_ns_class.element_form_default
+                                          end
+
+            child_options = options.dup
+            child_options[:parent_namespace_class] = parent_ns_class
+            child_options[:parent_element_form_default] =
+              parent_element_form_default
+            child_options[:parent_element] = parent
+          end
 
           element = yield(rule, value, child_options)
           parent.add_child(element) if element
@@ -428,7 +434,7 @@ text_node_count = 0, use_content_index = false)
         #   reconciliation could not place
         def apply_remaining_rules(model_instance, options, compiled_rules,
 mapping, processed_text_nodes, fallback_rules)
-          attr_order = model_instance.respond_to?(:attribute_order) &&
+          attr_order = model_instance.is_a?(Lutaml::Model::Serialize) &&
             model_instance.attribute_order
 
           rules_to_apply = if attr_order

data/lib/lutaml/xml/transformation.rb

@@ -265,6 +265,20 @@ module Lutaml
         # Loop-invariant for the whole ordered walk (see
         # apply_standard_rules): one merge per model, not per rule.
         rule_options = options.merge(current_model: model_instance)
+        # `root` is the parent of every element value this walk emits,
+        # so the parent context keys are walk-invariant too: set them
+        # once here and apply_element_rule_single's fast path reuses
+        # this hash for every value instead of merging per value.
+        # rule_options itself keeps the caller's parent context for
+        # the attribute/content/raw rules dispatched via apply_rule.
+        element_value_options = rule_options.dup
+        root_ns_class = root.namespace_class
+        element_value_options[:parent_namespace_class] = root_ns_class
+        element_value_options[:parent_element_form_default] =
+          if root_ns_class&.element_form_default_set?
+            root_ns_class.element_form_default
+          end
+        element_value_options[:parent_element] = root
         apply_rules_in_order(
           root, model_instance, options,
           compiled_rules, model_class, register_id
@@ -281,7 +295,7 @@ module Lutaml
               parent: root,
               rule: rule,
               value: value,
-              options: rule_options,
+              options: element_value_options,
             ) do |r, v, child_opts|
               element = create_element_for_value(r, v, child_opts, model_class,
                                                  register_id, register)

data/lib/lutaml/xml/type/serializers.rb

@@ -8,13 +8,20 @@ module Lutaml
       module Serializers
         module_function
 
+        # The default :xml String serializer is the identity for String
+        # values. Attribute#serialize_value fast-paths String→String
+        # through an identity comparison with this exact proc, so a
+        # consumer override of the serializer disables that fast path
+        # automatically.
+        STRING_XML_TO = ->(inst) { inst.value&.to_s }.freeze
+
         def register_all!
           v = Lutaml::Model::Type::Value
 
           # String — value&.to_s
           v.register_format_type_serializer(
             :xml, Lutaml::Model::Type::String,
-            to: ->(inst) { inst.value&.to_s },
+            to: STRING_XML_TO,
             from: ->(val) { Lutaml::Model::Type::String.cast(val) }
           )
 

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/lib/tasks/performance_probe_plan_walk.rb

@@ -47,7 +47,7 @@ end
 
 Lutaml::Model::Config.instance.xml_plan_fast_path = true
 measure.call("PlanWalk parse + 5000 model.new") do
-  result = Lutaml::Xml::PlanWalk.call(PlanWalkProbe::BulkRoot, xml)
+  result = Lutaml::Xml::Leptris::PlanWalk.call(PlanWalkProbe::BulkRoot, xml)
   raise "PlanWalk returned nil" unless result&.item&.size == 5000
 end
 

data/lutaml-model.gemspec

@@ -33,15 +33,18 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
   # required for liquid
-  spec.add_dependency "base64"
+  spec.add_dependency "base64", ">= 0.1.1"
   spec.add_dependency "bigdecimal"
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", "~> 0.5.56"
+  # 0.5.84 always passes XML_PARSE_HUGE to libxml2: very large documents
+  # parse completely instead of being silently truncated at the 10 MB
+  # input-buffer cap (lutaml-model#871).
+  spec.add_dependency "moxml", "~> 0.5.84"
   spec.add_dependency "ostruct"
-  spec.add_dependency "rubyzip", "~> 3.4"
-  spec.add_dependency "thor"
+  spec.add_dependency "rubyzip", "~> 3.7"
+  spec.add_dependency "thor", "~> 1.4"
 
   spec.metadata["rubygems_mfa_required"] = "true"
 end

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/key_value/transformation/value_serializer_spec.rb

@@ -5,11 +5,15 @@ require "spec_helper"
 RSpec.describe Lutaml::KeyValue::Transformation::ValueSerializer do
   let(:format) { :json }
   let(:register_id) { :default }
+  # No doubles (house rule): a real transformation factory. Under
+  # hash-direct emission (TODO.perf 19) transform returns the content
+  # hash itself.
   let(:transformation_factory) do
-    ->(_type_class) do
-      double("Transformation",
-             transform: double("Element",
-                               to_hash: { "__root__" => { "name" => "test" } }))
+    ->(type_class) do
+      Lutaml::KeyValue::Transformation.new(
+        type_class, type_class.mappings_for(format, register_id),
+        format, register_id
+      )
     end
   end
 
@@ -106,7 +110,7 @@ RSpec.describe Lutaml::KeyValue::Transformation::ValueSerializer do
       end
 
       it "validates type mismatch" do
-        wrong_value = double("wrong_type")
+        wrong_value = Object.new
         expect do
           serializer.serialize_item(wrong_value, rule)
         end.to raise_error(Lutaml::Model::IncorrectModelError, /but should be/)