lutaml-model 0.8.78 → 0.8.79

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb8929566d9265231917502a2f69360d8ae3f386a7dae26289bfd7764d08938
-  data.tar.gz: 6dd3b2b0eb762944dbd39ee8f799012d9b808c980030d9daaf8fb8fed9cbbec6
+  metadata.gz: baaf76af5592d1f15c959d624311b2275e3871728b7c74ca416032c743929134
+  data.tar.gz: cc5bc7a1cea2b151c51f720f971c8799d1d005e4ef7fc79fa415e611e161a2b5
 SHA512:
-  metadata.gz: 2f495fccd94badb5057c976aec507acbcf8319bf0f4cf56783ad0d9cade2f982a0806b473a6e89ed7496d6baa4cb8e05aa871bccf5d432c963c6e66c8ad22661
-  data.tar.gz: 44bc1cc78b2ef1e8f75e9d0237d35eab9dc4d2d5d0f49efed9966c87933a607f49724999c7854cbd428f5a6fd4c2fdc945bd1750876ab2f603d25986b2169b01
+  metadata.gz: 68ab1cf58c777ef8f508c9c3e10df0026ea2de6affb69fa76f8c25e262dfdce8cdd5d67caccb7672eedeea233a654c5e3cd1c5c16ed3c7a4688f02937e46c897
+  data.tar.gz: 53b98253d7946438a13ac912701a271aa32f549525ca17b0645243a2669631dc79ee728928ee808e9a7660c0f3bbd2e963d3cdcc17b70f2adb2419aab68e8904

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.79"
   end
 end

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.79
 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