lutaml-model 0.8.67 → 0.8.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52c9d5f90fb80dbbec116f4a6e8d65e92d8b5fe3181a9a4b7aa26349b64d8938
-  data.tar.gz: 657ef667d7d9192a6f6d6592168c8bf5c3a3f25aeff8fa4127d4438954ac7bf0
+  metadata.gz: f8ea7edf1c5b0a9d5e208fb6a83df7f40eba0a83e9ac78797130269e1a3cba7c
+  data.tar.gz: 7f2d97eac672eae74a1a192db0196305d62c45d3bd1f34855fb30a79475d6f88
 SHA512:
-  metadata.gz: 14797b4e4855ac206622648c2ae5cf01b5115e9a243f461861d90e78903a80df356d35144b024801dd9556ed3d89fe526069157faf5bceb804088829be768be4
-  data.tar.gz: 179a58214dc093680917167055d3f3deec644303b310c91763d27c6aed18b19fc1e5668dea0c8a1a1e3542ef54b8d39712ade45a869ee0c072f1bb92ae10c18f
+  metadata.gz: e202fb8a65018521903d42867ecd434df1f84c8568eab99f0f4e737651b6ecb51e91fc60c9b188aecc8e65f645bb10f9103a73b70617356a05c9d7ba566c8c8a
+  data.tar.gz: cabf97f1c9aaf7432a4831d3c5b5fec4d54306a073f9deb4e1e2cb4bf7ad97b608b52775cfef0b73294c51fd794368531c521386bb55a84ac2c1c23ad4004e56

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

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/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/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.67"
+    VERSION = "0.8.69"
   end
 end

metadata

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