lutaml-model 0.8.66 → 0.8.68

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1a4f0f42471c24f887cb31b50be356825d1bb538ca568b30d15a703928c7d0b
-  data.tar.gz: b2b5227d2f505a10921d41123caf0f04b2cafec68ab0318db49690d394d1309a
+  metadata.gz: '08259545535ddbd9c57aad9adfcb1fa66ebf9179fe00cbfa6be408285d1cdca5'
+  data.tar.gz: 84c75404c371bb433b18d9cc87fab24b252b15fe8c2555544fc7b12478ff37c6
 SHA512:
-  metadata.gz: 191a88d3dc8eacc1e94c8ea2b033500dbb4ce77345feefb6e7328527c4648c67575d10db7f9cb9e4d9611fada0902210077ae5c6ec0fcc4ff457b8637f35e2ef
-  data.tar.gz: fe6e34251e26d5593ec07873e5f0320a0802e0cd3c86ec89b8492c9add49c11f919dedd4aef225f6b8b63ca6564c0d3841f88d16b614fe265c8ebf3fb27fdb00
+  metadata.gz: 2b730dcc7e7f555270929f4a42eb9b7a2f7e2d26a4a73fb1c75cbaa6415d2d54c0c5674ba2fad1bdba1cda106c3f625f19eed4db5d58d59334c79311c5dc46ad
+  data.tar.gz: 4a8fa22b33898a088d8ba3e9a2b00c8bed316f73a0d0e2dcca776aa290f484bf9519952c7e2076161779faaff4aa5d16fb3be52b10e963366369bf663d75d6f4

data/lib/lutaml/key_value/mapping_rule.rb

@@ -83,6 +83,13 @@ module Lutaml
       def root_mapping?
         name == "root_mapping"
       end
+
+      # The writer symbol for this rule's target, interned once per
+      # rule: the interpolation allocated a String and interned it per
+      # row per document in the transform's hot loop.
+      def kv_setter
+        @kv_setter ||= :"#{to}="
+      end
     end
   end
 end

data/lib/lutaml/key_value/transform.rb

@@ -1,5 +1,6 @@
 module Lutaml
   module KeyValue
+    MISSING = Object.new.freeze
     class Transform < Lutaml::Model::Transform
       def data_to_model(data, format, options = {})
         # Use child's own default register if it has one
@@ -208,14 +209,17 @@ module Lutaml
         children = []
         absent = []
         rows.each do |rule, attr, kind, type, child_rows|
-          unless Lutaml::Model::Utils.string_or_symbol_key?(doc, rule.name)
+          # One hash pass per row: fetch with a sentinel distinguishes
+          # absent keys from present-nil values (both read as nil), so
+          # the separate string_or_symbol_key? probe goes away.
+          v = Lutaml::Model::Utils.fetch_str_or_sym(doc, rule.name, MISSING)
+          if v.equal?(MISSING)
             absent << rule
             next
           end
-          v = Lutaml::Model::Utils.fetch_str_or_sym(doc, rule.name)
 
           if kind == :scalar
-            setters << [:"#{rule.to}=", v]
+            setters << [rule.kv_setter, v]
             next
           end
 
@@ -239,7 +243,7 @@ module Lutaml
 
               built << child
             end
-            setters << [:"#{rule.to}=", built]
+            setters << [rule.kv_setter, built]
             children.concat(built)
           else
             return nil unless v.is_a?(::Hash)
@@ -249,7 +253,7 @@ module Lutaml
                                                  options)
             return nil if child.nil?
 
-            setters << [:"#{rule.to}=", child]
+            setters << [rule.kv_setter, child]
             children << child
           end
         end

data/lib/lutaml/model/attribute.rb

@@ -316,6 +316,16 @@ module Lutaml
         @unresolved_type || @type
       end
 
+      def reference_type?
+        (@reference_type ||= unresolved_type == Lutaml::Model::Type::Reference)
+      end
+
+      def value_map_boolean?
+        (@value_map_boolean ||=
+           type == Lutaml::Model::Type::Boolean ||
+           unresolved_type == Lutaml::Model::Type::Boolean)
+      end
+
       def polymorphic?
         @options[:polymorphic_class]
       end
@@ -438,8 +448,7 @@ module Lutaml
 
         option = value_map[key]
         if (option.is_a?(TrueClass) || option.is_a?(FalseClass)) &&
-            (type == Lutaml::Model::Type::Boolean ||
-             unresolved_type == Lutaml::Model::Type::Boolean)
+            value_map_boolean?
           return option
         end
 
@@ -507,7 +516,8 @@ module Lutaml
         return resolved_type.new(value) if value.is_a?(::Hash) && !hash_type?
 
         # Special handling for Reference types - pass the metadata
-        if unresolved_type == Lutaml::Model::Type::Reference
+        # (the comparison is attribute-constant; memoize the verdict)
+        if reference_type?
           return resolved_type.cast_with_metadata(value,
                                                   @options[:ref_model_class], @options[:ref_key_attribute])
         end
@@ -566,10 +576,15 @@ instance_object = nil)
       end
 
       def default_value(register, instance_object = nil)
-        if delegate
-          type(register).attributes(register)[to].default(register,
-                                                          instance_object)
-        elsif options[:default].is_a?(Proc)
+        # The kind is fixed at definition; the common case (no default
+        # at all) paid three option checks per absent attribute per
+        # instantiation before the memo.
+        case (@default_kind ||= _default_kind)
+        when :none
+          Lutaml::Model::UninitializedClass.instance
+        when :static
+          options[:default]
+        when :proc
           if instance_object
             ::Lutaml::Model::Attribute.evaluating_default do
               instance_object.instance_exec(&options[:default])
@@ -577,13 +592,20 @@ instance_object = nil)
           else
             options[:default].call
           end
-        elsif options.key?(:default)
-          options[:default]
-        else
-          Lutaml::Model::UninitializedClass.instance
+        else # :delegate
+          type(register).attributes(register)[to].default(register,
+                                                          instance_object)
         end
       end
 
+      def _default_kind
+        return :delegate if delegate
+        return :proc if options[:default].is_a?(Proc)
+        return :static if options.key?(:default)
+
+        :none
+      end
+
       # Marks the dynamic extent in which a default proc runs against a
       # model instance, so Serialize#method_missing can fall back to the
       # model class for methods the instance does not define (0.7.x

data/lib/lutaml/model/version.rb

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

data/lib/lutaml/xml/plan_hydrator.rb

@@ -66,14 +66,14 @@ module Lutaml
         def attributes_kwargs(plan, value, node = nil)
           kwargs = {}
           sole_claimants = sole_claimant_names(plan)
-          plan[:attr_rows].each do |rule, attr|
-            v = value.attribute(rule.name.to_s)
-            if v.nil? && node && sole_claimants.include?(rule.name.to_s)
+          plan_attr_rows(plan).each do |rule, attr, name|
+            v = value.attribute(name)
+            if v.nil? && node && sole_claimants.include?(name)
               # #754/#790 parity: a sole-claimant attribute rule binds
               # any qualification (the interpretive matcher's lenient
               # recovery). The walk captures exact (URI, local) matches
               # only, so the qualified spelling is read off the node.
-              v = lenient_node_attribute(node, rule.name.to_s)
+              v = lenient_node_attribute(node, name)
             end
             next if v.nil?
 
@@ -86,6 +86,15 @@ module Lutaml
           kwargs
         end
 
+        # Wire-name strings are plan-frozen; materializing them per
+        # hydration allocated two or three strings per attribute row
+        # per instance.
+        def plan_attr_rows(plan)
+          plan[:attr_row_names] ||= plan[:attr_rows].map do |rule, attr|
+            [rule, attr, rule.name.to_s]
+          end
+        end
+
         # Returns [kwargs, hydrated_child_instances, delegate_values]
         # — child instances come back so the caller can decorate
         # parent/root links once the parent exists; delegate values
@@ -364,10 +373,11 @@ module Lutaml
         # names eligible for #754/#790 lenient binding (multi-claimant
         # names stay exact; per #841 leniency is sole-claimant-only).
         def sole_claimant_names(plan)
-          plan[:attr_rows].map { |rule, _attr| rule.name.to_s }
-            .tally
-            .select { |_n, c| c == 1 }
-            .keys
+          # Frozen with the plan: recomputing the tally per hydration
+          # showed in the #876-era profile as Enumerable#find/tally churn.
+          plan[:sole_claimants] ||= plan[:attr_rows]
+            .map { |rule, _attr| rule.name.to_s }.tally
+            .select { |_n, c| c == 1 }.keys
         end
 
         # Local-name attribute lookup on the source node, qualified
@@ -391,9 +401,12 @@ module Lutaml
           want_tags = !row_tags.nil?
           value.count.times do |i|
             child = value.at(i)
-            next if child.name.nil? # content runs, read separately
+            # One FFI crossing per child: the name was read twice here
+            # (nil check + bucket key), doubling the hottest accessor.
+            name = child.name
+            next if name.nil? # content runs, read separately
 
-            (grouped[child.name] ||= []) << child
+            (grouped[name] ||= []) << child
             if want_tags && child.type_tag != 0
               (tagged[child.type_tag] ||= []) << child
             end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.66
+  version: 0.8.68
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-26 00:00:00.000000000 Z
+date: 2026-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64