lutaml-model 0.8.78 → 0.8.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb8929566d9265231917502a2f69360d8ae3f386a7dae26289bfd7764d08938
-  data.tar.gz: 6dd3b2b0eb762944dbd39ee8f799012d9b808c980030d9daaf8fb8fed9cbbec6
+  metadata.gz: 8375b9ceb21e41c8f236b2e96728983065a6b547f31401686ab5b9b520db2d8d
+  data.tar.gz: 3e9f7da096049d3cf0472a18782f014341df12b8ae0e0394dcab18a24de73c9b
 SHA512:
-  metadata.gz: 2f495fccd94badb5057c976aec507acbcf8319bf0f4cf56783ad0d9cade2f982a0806b473a6e89ed7496d6baa4cb8e05aa871bccf5d432c963c6e66c8ad22661
-  data.tar.gz: 44bc1cc78b2ef1e8f75e9d0237d35eab9dc4d2d5d0f49efed9966c87933a607f49724999c7854cbd428f5a6fd4c2fdc945bd1750876ab2f603d25986b2169b01
+  metadata.gz: 8c925f539d5fdb6ca0e57dae30b6e3b4fe8ed162fbfdb8dc66f04661c885399eefdd99259a7f3067b9a98cab678fb6b9b3d5176418e6d80c7d2ec2b58eea86aa
+  data.tar.gz: 8673fafc5fc984374916bf509e855ce69dcfd89134149d9e348b7f56eede5b95b6e4e0eca064c1cc0dfdcb169aecf27b47a75251a4cd3dc7c356c92ef05da317

data/bench/bench_alloc_audit.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module AllocAudit
+  class Row < Lutaml::Model::Serializable
+    attribute :id, :integer
+    attribute :name, :string
+
+    xml do
+      root "row"
+      map_element "id", to: :id
+      map_element "name", to: :name
+    end
+
+    json do
+      map "id", to: :id
+      map "name", to: :name
+    end
+  end
+
+  class Doc < Lutaml::Model::Serializable
+    attribute :rows, AllocAudit::Row, collection: true
+
+    xml do
+      root "doc"
+      map_element "row", to: :rows
+    end
+
+    json do
+      map "rows", to: :rows
+    end
+  end
+
+  DOC = Doc.new(rows: Array.new(500) { |i| Row.new(id: i, name: "n#{i}") })
+
+  def self.alloc
+    GC.start
+    before = GC.stat(:total_allocated_objects)
+    yield
+    GC.stat(:total_allocated_objects) - before
+  end
+
+  3.times do
+    DOC.to_xml
+    DOC.to_json
+    DOC.to_hash
+  end
+
+  puts "rows=500"
+  puts "to_xml_alloc=#{alloc { DOC.to_xml }}"
+  puts "to_json_alloc=#{alloc { DOC.to_json }}"
+  puts "to_hash_alloc=#{alloc { DOC.to_hash }}"
+  puts "from_xml_alloc=#{alloc { Doc.from_xml(DOC.to_xml) }}"
+  puts "from_json_alloc=#{alloc { Doc.from_json(DOC.to_json) }}"
+end

data/lib/lutaml/model/attribute.rb

@@ -9,6 +9,17 @@ module Lutaml
       include DeepDupable
       include RestrictionValidation
 
+      # Symbol interpolation (:"to_#{format}") allocates a String and a
+      # Symbol per call on the serialization hot path; the table serves
+      # the known formats and the fallback keeps exotic ones working.
+      TO_FORMAT_METHODS = {
+        xml: :to_xml,
+        json: :to_json,
+        yaml: :to_yaml,
+        toml: :to_toml,
+        hash: :to_hash,
+      }.freeze
+
       ALLOWED_OPTIONS = %i[
         raw
         default
@@ -838,11 +849,10 @@ instance_object = nil)
         return value if value.nil? || Utils.uninitialized?(value)
 
         resolved_type = options[:resolved_type] || type(register)
-        serialize_options = options.merge(resolved_type: resolved_type)
         value = reference_key(value) if unresolved_type == Lutaml::Model::Type::Reference
         if collection_instance?(value)
           return serialize_array(value, format, register,
-                                 serialize_options)
+                                 options.merge(resolved_type: resolved_type))
         end
         if resolved_type <= Serialize
           return serialize_model(value, format, register,
@@ -1223,8 +1233,19 @@ instance_object = nil)
       end
 
       def serialize_value(value, format, resolved_type)
-        value = wrap_in_type_if_needed(value, resolved_type)
-        value.public_send(:"to_#{format}")
+        # The Value wrapper is a pass-through on the to_ side (its
+        # to_<format> returns the wrapped raw value unless a custom
+        # format serializer is registered), so the common path returns
+        # the raw value and lets the caller stringify — one object
+        # instead of three per serialized scalar. Reference and
+        # custom-serializer rows keep the wrapped path.
+        if resolved_type <= Type::Reference ||
+            Type::Value.format_type_serializer_for(format, resolved_type)&.dig(:to)
+          value = wrap_in_type_if_needed(value, resolved_type)
+          return value.public_send(TO_FORMAT_METHODS[format] || :"to_#{format}")
+        end
+
+        value
       end
 
       def wrap_in_type_if_needed(value, resolved_type)

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -182,13 +182,18 @@ module Lutaml
       alias from name
       alias render_default? render_default
 
+      # Frozen default: render? only reads options (render_nil?/render_empty?/
+      # render_omitted? policies); a fresh {} per call is pure churn on the
+      # serialization hot path.
+      EMPTY_RENDER_OPTIONS = {}.freeze
+
       # Whether this rule participates in serialization output. False
       # marks a hydrate-only mapping: consumed by from_* but never
       # rendered by to_*. (The value callback #serialize is separate.)
       def serialize? = @serialize_mapping
       alias attribute? attribute
 
-      def render?(value, instance = nil, options = {})
+      def render?(value, instance = nil, options = EMPTY_RENDER_OPTIONS)
         if invalid_value?(value, options)
           false
         # FIXED: Check if collection was mutated after initialization

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.78"
+    VERSION = "0.8.80"
   end
 end

data/lib/lutaml/xml/plan_hydrator.rb

@@ -107,7 +107,9 @@ module Lutaml
           kwargs = {}
           children = []
           delegates = []
-          spellings = Hash.new { |h, k| h[k] = [] }
+          # Lazy: models without multi-spelling rows never touch it, and
+          # the block-backed Hash is a fresh object per hydrated row.
+          spellings = nil
           row_tags = plan[:row_tags]
           plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate), idx|
             tag = row_tags&.[](idx)
@@ -174,6 +176,7 @@ module Lutaml
                 assign(kwargs, delegates, delegate, rule, attr, values)
               end
             when :spelling
+              spellings ||= Hash.new { |h, k| h[k] = [] }
               spellings[[rule, attr]] << grouped[spelling.to_s].to_a
             when :nested
               child_type = attr.type(register)
@@ -193,7 +196,7 @@ module Lutaml
                      attr.collection? ? items : items.first)
             end
           end
-          unless spellings.empty?
+          unless !spellings || spellings.empty?
             spellings.each do |(rule, attr), groups|
               # Interpretive order for shared-attribute groups is
               # spelling-group order (first spelling's matches, then
@@ -397,8 +400,8 @@ module Lutaml
 
         def group_children(value, row_tags = nil)
           grouped = {}
-          tagged = {}
           want_tags = !row_tags.nil?
+          tagged = want_tags ? {} : nil
           value.count.times do |i|
             child = value.at(i)
             # One FFI crossing per child: the name was read twice here

data/lib/lutaml/xml/plan_serializer.rb

@@ -73,10 +73,17 @@ module Lutaml
             when :scalar
               # Multi-capture parity: an attribute that collected
               # several occurrences serializes one element per item,
-              # as the interpretive writer does.
-              Array(value).each do |item|
+              # as the interpretive writer does. A plain scalar skips
+              # the Array() wrap — the common case.
+              if value.is_a?(::Array)
+                value.each do |item|
+                  add_leaf(element, row_name(rule, spelling),
+                           attr.serialize(item, :xml, reg), doc,
+                           attrs: rule.when_attribute)
+                end
+              else
                 add_leaf(element, row_name(rule, spelling),
-                         attr.serialize(item, :xml, reg), doc,
+                         attr.serialize(value, :xml, reg), doc,
                          attrs: rule.when_attribute)
               end
             when :collection_native, :collection_cb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.78
+  version: 0.8.80
 platform: ruby
 authors:
 - Ribose Inc.
@@ -181,6 +181,7 @@ files:
 - Rakefile
 - bench/baselines/.gitkeep
 - bench/bench_all.rb
+- bench/bench_alloc_audit.rb
 - bench/bench_common.rb
 - bench/bench_compare.rb
 - bench/bench_mml.rb