lutaml-model 0.8.68 → 0.8.70

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08259545535ddbd9c57aad9adfcb1fa66ebf9179fe00cbfa6be408285d1cdca5'
-  data.tar.gz: 84c75404c371bb433b18d9cc87fab24b252b15fe8c2555544fc7b12478ff37c6
+  metadata.gz: 2e3d309f15ab3866bd793f01385378fc7294127de341e8914a27838bfd6b956c
+  data.tar.gz: ac90f885dd393c008adb09187586ec2698d9e1f40a8f3fd9bb579ad12e776fe3
 SHA512:
-  metadata.gz: 2b730dcc7e7f555270929f4a42eb9b7a2f7e2d26a4a73fb1c75cbaa6415d2d54c0c5674ba2fad1bdba1cda106c3f625f19eed4db5d58d59334c79311c5dc46ad
-  data.tar.gz: 4a8fa22b33898a088d8ba3e9a2b00c8bed316f73a0d0e2dcca776aa290f484bf9519952c7e2076161779faaff4aa5d16fb3be52b10e963366369bf663d75d6f4
+  metadata.gz: 5911aff11ba087c00b6854ee18106df409516688b093e28149f6dbff8c31ea00d15cc82ff67cfe85fbb0c61d34d0d14849d43d1c4e2a114be41e244d293f5b1c
+  data.tar.gz: 91b861ce8a517ee382284684f2516493d96f5aef6a1588e9a01eefb1108e9fb86a37a91dbbda39cf02a0b38f32ce8f9603dc5498f2e7b4fec647d21bfaca6587

data/lib/lutaml/key_value/transform.rb

@@ -177,18 +177,21 @@ module Lutaml
             .substitution_for(type).any?
 
           if type.is_a?(Class) && type.include?(Lutaml::Model::Serialize)
-            child_rows = kv_group_plan(type, format,
-                                       Lutaml::Model::Register
-                                         .resolve_for_child(type, register))
+            child_register = Lutaml::Model::Register
+              .resolve_for_child(type, register)
+            child_rows = kv_group_plan(type, format, child_register)
             return false unless child_rows
 
             rows ||= []
-            rows << [rule, attr, :model, type, child_rows]
+            # child_register rides the row: the plan was BUILT under it,
+            # and rebuilding the resolution per model row per document
+            # cost a Concurrent::Map hop each time (TODO.perf 14).
+            rows << [rule, attr, :model, type, child_rows, child_register]
           elsif type.is_a?(Class) && type < Lutaml::Model::Type::Value &&
               !attr.value_policy.whole_value?(type) &&
               !Lutaml::Model::Attribute.custom_from_probe?(type)
             rows ||= []
-            rows << [rule, attr, :scalar, nil, nil]
+            rows << [rule, attr, :scalar, nil, nil, nil]
           else
             return false
           end
@@ -208,7 +211,7 @@ module Lutaml
         setters = []
         children = []
         absent = []
-        rows.each do |rule, attr, kind, type, child_rows|
+        rows.each do |rule, attr, kind, type, child_rows, child_register|
           # 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.
@@ -223,8 +226,6 @@ module Lutaml
             next
           end
 
-          child_register = Lutaml::Model::Register.resolve_for_child(type,
-                                                                     register)
           if attr.collection?
             # A present-but-nil collection reaches the per-rule walk,
             # which owns the sentinel interplay for that edge

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -151,8 +151,19 @@ model_class: nil)
             return value.public_send(:"to_#{format}")
           end
 
-          # Wrap value in type and call to_#{format}
           if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
+            plan = serialize_plan(rule)
+            # Identity only under identity_fast_type's exact condition
+            # (no custom to AND no custom from): a custom from means the
+            # wrapper constructor normalizes the value, so the raw value
+            # must still pass through it.
+            if plan[:identity_type] && value.instance_of?(plan[:identity_type])
+              return value
+            end
+            if (to_fn = plan[:to_fn])
+              return to_fn.call(rule.attribute_type.new(value))
+            end
+
             wrapped_value = rule.attribute_type.new(value)
             wrapped_value.public_send(:"to_#{format}")
           else
@@ -187,9 +198,23 @@ model_class: nil)
             reference: reference_type?(rule),
             union: ::Lutaml::Model::Type::Union.rule?(rule),
             nested: nested_model?(rule),
+            # The custom to_<format> serializer, resolved once per rule:
+            # the default path is pure identity (to_<format> returns the
+            # wrapped .value), so values without a custom serializer skip
+            # the wrap-allocate-cast ceremony entirely, and custom ones
+            # skip the per-value registry lookup.
+            to_fn: custom_to_fn(rule),
           }
         end
 
+        def custom_to_fn(rule)
+          type = rule.attribute_type
+          return nil unless type.is_a?(::Class) && type < ::Lutaml::Model::Type::Value
+
+          ::Lutaml::Model::Type::Value
+            .format_type_serializer_for(@format, type)&.fetch(:to, nil)
+        end
+
         # Builtin scalars whose type registers no custom to_<format>
         # serializer serialize as the value itself — Type::Value#to_<format>'s
         # default — without the wrap-allocate-cast ceremony per field.

data/lib/lutaml/model/render_policy.rb

@@ -12,6 +12,14 @@ module Lutaml
     # options are normalized into value_map entries at MappingRule construction
     # time, so downstream code never needs to re-interpret them.
     module RenderPolicy
+      # Isolated holder: host transformations freeze after compile; an
+      # ivar cache on them raises FrozenError (learned the hard way).
+      SKIP_PLANS = ::Class.new do
+        def self.cache
+          @cache ||= {}.compare_by_identity
+        end
+      end.cache
+
       def self.derived_attribute_for?(context_obj, attr_name)
         return false unless context_obj.is_a?(Lutaml::Model::Serialize) &&
           context_obj.class.is_a?(Class) &&
@@ -52,16 +60,26 @@ module Lutaml
       # @param context_obj [Object] The context object (model_instance or delegate_obj)
       # @return [Boolean] true if should skip
       def check_skip_logic?(value, rule, context_obj)
-        attr_name = extract_attribute_name(rule)
-
-        to_map = to_value_map(rule)
-
-        case value
-        when nil
+        # Rule-constant parts (attribute name, :to value map) are frozen
+        # per rule; recomputing them per value showed in the to_yaml
+        # wall profile. The host transformation freezes itself after
+        # compile, so the cache lives in an isolated holder (TypeProbeCache
+        # precedent): host object -> identity-keyed rule plans.
+        per_host = (SKIP_PLANS[self] ||= {}.compare_by_identity)
+        skip_plan = (per_host[rule] ||= [extract_attribute_name(rule), to_value_map(rule)])
+        attr_name, to_map = skip_plan
+
+        # Plain conditionals, not `when ->(v)` literals: each lambda
+        # literal in a case/when allocates on every call — two per
+        # value here, 16% of to_yaml's allocations in the object-mode
+        # profile.
+        if value.nil?
           return to_map[:nil] == :omitted
-        when ->(v) { Lutaml::Model::Utils.empty?(v) }
+        end
+        if Lutaml::Model::Utils.empty?(value)
           return to_map[:empty] == :omitted
-        when ->(v) { Lutaml::Model::Utils.uninitialized?(v) }
+        end
+        if Lutaml::Model::Utils.uninitialized?(value)
           return to_map[:omitted] == :omitted || to_map[:omitted].nil?
         end
 

data/lib/lutaml/model/serialize.rb

@@ -197,8 +197,11 @@ module Lutaml
       end
 
       def attr_value(attrs, name, attribute)
-        value = Utils.fetch_str_or_sym(attrs, name,
-                                       attribute.default(lutaml_register, self))
+        # The default is computed only on absence: it used to be
+        # evaluated eagerly as the fetch fallback on EVERY value,
+        # paying proc/static default dispatch per present attribute.
+        value = Utils.fetch_str_or_sym(attrs, name, Utils::MISSING)
+        value = attribute.default(lutaml_register, self) if value.equal?(Utils::MISSING)
         attribute.cast_value(value, lutaml_register)
       end
 
@@ -368,15 +371,20 @@ module Lutaml
           value = self.class.apply_value_map(value, vmap, attr)
           # Performance: Only call ensure_utf8 for string values
           value = self.class.ensure_utf8(value) if value.is_a?(::String)
-          public_send(:"#{name}=", value)
+          # Interpolating the writer symbol allocated a String per
+          # attribute per instance; the per-register writer table is
+          # interned once per class.
+          public_send(self.class.instantiate_writers(lutaml_register)[name], value)
           using_default_for(name) if default
         end
       end
 
       def determine_value(attrs, name, attr)
-        if attrs.key?(name) || attrs.key?(name.to_s)
-          return attr_value(attrs, name, attr)
-        end
+        # One hash pass: a sentinel fetch distinguishes absent keys
+        # from present-nil values, replacing two key probes plus the
+        # re-fetch inside attr_value (four hash ops per attribute).
+        value = Utils.fetch_str_or_sym(attrs, name, Utils::MISSING)
+        return attr.cast_value(value, lutaml_register) unless value.equal?(Utils::MISSING)
 
         resolved = attr.default_value(lutaml_register, self)
         return Lutaml::Model::UninitializedClass.instance if Lutaml::Model::Utils.uninitialized?(resolved)

data/lib/lutaml/model/type/value.rb

@@ -67,12 +67,14 @@ from: nil)
           # @param type_class [Class] the type class to look up
           # @return [Hash, nil] { to: Proc, from: Proc } or nil
           def format_type_serializer_for(format, type_class)
-            # Hot path: memoize per [format, resolved class] — the hierarchy
-            # walk below only runs on a miss. Format serializers register at
-            # load time, so a hit is stable.
-            cache = SERIALIZER_LOOKUP_CACHE
-            key = [format, type_class]
-            return cache[key] if cache.key?(key)
+            # Hot path: memoized per format -> class with NO key
+            # allocation — the previous [format, class] array key
+            # allocated on every lookup (2k arrays per 200 serializes in
+            # the object-mode profile). Identity-keyed nested maps; the
+            # hierarchy walk below only runs on a miss, and format
+            # serializers register at load time, so a hit is stable.
+            per_format = (SERIALIZER_LOOKUP_CACHE[format] ||= {}.compare_by_identity)
+            return per_format[type_class] if per_format.key?(type_class)
 
             klass = type_class
             found = nil
@@ -85,7 +87,7 @@ from: nil)
 
               klass = klass.superclass
             end
-            cache[key] = found
+            per_format[type_class] = found
             found
           end
 

data/lib/lutaml/model/utils.rb

@@ -3,6 +3,10 @@
 module Lutaml
   module Model
     module Utils
+      # Fetch sentinel distinguishing absent keys from present-nil
+      # values; shared by the deserialization fast paths.
+      MISSING = Object.new.freeze
+
       class << self
         UNINITIALIZED = Lutaml::Model::UninitializedClass.instance
 

data/lib/lutaml/model/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.68
+  version: 0.8.70
 platform: ruby
 authors:
 - Ribose Inc.