lutaml-model 0.8.89 → 0.8.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 674e1b00fc0235ada741c4dbaaf79a4689658ef83d9dd41343574534d222f102
-  data.tar.gz: 8b503f6c599bc078a790fb776adfc8798b1ba493bf1c4c437a8eb5d00dc20c85
+  metadata.gz: f05bb7edf0d4a86ba5bc0105d3d269b2f3c28532cdd88e03be857fb4e426a505
+  data.tar.gz: 806a73d21e506337a5d039563225e3b000e7f1a3c0e701ca58ae8d58fdbe3c8d
 SHA512:
-  metadata.gz: 9d995eff1c230ffa398ec5f87f5c200f6f9f7e997146204137f850513a8d2d70443ccac4abbbc18bdb4e14d0cb4f6fac6da3047ff94dad06d76a07d475f4fb51
-  data.tar.gz: 3ded44d612d6ef9ac0b66030494c90984dadd25ddca4d286bbbf516b8dfb9d01b247e2a24422bf3f67c22a5dec010709120c431a04b8df5a74b2db721fb0942c
+  metadata.gz: 0d02bf01cd956193aeab21358508339542b2f104c767347dd7fd2fbc7134c461692d4358f755e952082570683e7ecaf0e39c989d977d5b458b87807892b24997
+  data.tar.gz: e833ac9280da9e33ebb3427f6d34d53f3da5dd5f7d43d408144cefc4c5087507cc92013b956d1d7b857a4d4e5bde119e58ea926195f07d95eba4ceef4e73a704

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::Leptris::PlanCompiler.stats)
+    pp(Lutaml::Xml::Leptris::PlanCompiler.plan_stats)
   end
 end
 require "benchmark"

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.89"
+    VERSION = "0.8.91"
   end
 end

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

@@ -26,9 +26,9 @@ module Lutaml
       # metadata) completes.
       module PlanCompiler
         # TODO.perf/15: env-gated histogram of why models opt out of the
-        # plan path. Set PLAN_COMPILE_STATS=1 and read PlanCompiler.stats
-        # after a parse. Zero cost when disabled.
-        def self.stats
+        # plan path. Set PLAN_COMPILE_STATS=1 and read
+        # PlanCompiler.plan_stats after a parse. Zero cost when disabled.
+        def self.plan_stats
           @plan_stats ||= Hash.new(0)
         end
 

data/lib/lutaml/xml/namespace.rb

@@ -58,7 +58,10 @@ module Lutaml
         # @param value [String, nil] the namespace URI
         # @return [String, nil] the namespace URI
         def uri(value = nil)
-          @uri_value = value if value
+          if value
+            @uri_value = value
+            @to_key = nil
+          end
           @uri_value
         end
 
@@ -130,6 +133,7 @@ module Lutaml
         def prefix_default(value = nil)
           if value
             @prefix_default_value = value.to_s
+            @to_key = nil
           end
           @prefix_default_value
         end
@@ -286,13 +290,19 @@ module Lutaml
         #
         # @api private
         def to_key
-          prefix = prefix_default
-          namespace_uri = uri
-
-          if prefix && !prefix.empty?
-            "#{prefix}:#{namespace_uri}"
-          else
-            ":#{namespace_uri}"
+          # Called per element on the serialize path (90k births per
+          # 200-paragraph to_xml); memoized since uri/prefix_default
+          # are set at class-definition time. The setters above
+          # invalidate on reconfiguration.
+          @to_key ||= begin
+            prefix = prefix_default
+            namespace_uri = uri
+
+            if prefix && !prefix.empty?
+              "#{prefix}:#{namespace_uri}"
+            else
+              ":#{namespace_uri}"
+            end
           end
         end
 

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/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

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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.89
+  version: 0.8.91
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64