lutaml-model 0.8.34 → 0.8.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65361e31ef80bfd3600c0bc3ea4241c2b9a9e9d227b1772b9bd23f3324e92ad7
-  data.tar.gz: da258d5127e14511cd77bd1ca44e6ad1647aaaf445cc14a92102096f180a82a3
+  metadata.gz: 0a5f36f080c15bb2639142a36b424853d26458732c867963dbf7a99d6a1cd189
+  data.tar.gz: 3159ba755e2cc317e5e9b3785b2be1cffb08e424b2bd792bca34f20c853d25be
 SHA512:
-  metadata.gz: 2d5ece44cac496100e30c2d4f3c5ca3934f656bd81352ee9215e57c2a4b8563f0a7a8ae3c155909eaf132efcce992e1954731b89cd79808fcf8c948555b06abd
-  data.tar.gz: 9db5fc0ac630ad33336250d06a953357d8a2d60bb0f0cae037d5a2d9d6cc12da2fca2937aa5b73c5b490852381995937fad226049e51fd167906e900084fa837
+  metadata.gz: e83080b05e3277310d103e84c5f63fda7e963e25bb1cdc764934a1d931e388f212b51f97c5a02182966b3e376a97d00fc30fa396568a644100b5745064d1fd1a
+  data.tar.gz: f59d08e3915dacf3a7da3c0bfbc2e9b300cb7c66177c6dd4455870349fc4f2cb892d8d34a1028b74f2660b87e21980b44a4e941329fcf8a69687fde9a7d336f0

data/.rspec

@@ -1,3 +1,4 @@
 --format documentation
 --color
 --require spec_helper
+--tag ~benchmark

data/lib/lutaml/model/attribute.rb

@@ -52,11 +52,13 @@ module Lutaml
         # Public reader for compiled rule plans: does this type class carry a
         # custom from_xml/from_json (answer static, probed once)?
         def custom_from_probe?(type)
-          TypeProbeCache.cache[type] ||= begin
-            base = Lutaml::Model::Type::Value.singleton_class
+          cache = TypeProbeCache.cache
+          return cache[type] if cache.key?(type)
+
+          base = Lutaml::Model::Type::Value.singleton_class
+          cache[type] =
             type.method(:from_xml).owner != base ||
-              type.method(:from_json).owner != base
-          end
+            type.method(:from_json).owner != base
         end
       end
 

data/lib/lutaml/model/register.rb

@@ -80,15 +80,22 @@ module Lutaml
       # @param parent_register [Symbol, String, nil] The parent's register/context ID
       # @return [Symbol, nil] The register ID to use for the child
       def self.resolve_for_child(child_class, parent_register)
-        cache_key = [child_class.object_id, parent_register]
-
         if Lutaml::Model.opal?
-          return RESOLVE_CACHE[cache_key] if RESOLVE_CACHE.key?(cache_key)
+          per_class = RESOLVE_CACHE[child_class] # rubocop:todo Style/IdenticalConditionalBranches
+          return per_class[parent_register] if per_class&.key?(parent_register)
 
-          RESOLVE_CACHE[cache_key] =
+          (RESOLVE_CACHE[child_class] ||= {})[parent_register] =
             _resolve_for_child_uncached(child_class, parent_register)
         else
-          RESOLVE_CACHE.compute_if_absent(cache_key) do
+          # Nested maps: class → register → result. Every hop keys on a
+          # stable object (Class / Symbol), so the hot lookup allocates
+          # nothing — the flat [object_id, register] array key cost one
+          # Array per call, six per parsed element.
+          per_class = RESOLVE_CACHE[child_class] # rubocop:todo Style/IdenticalConditionalBranches
+          per_class ||= RESOLVE_CACHE.compute_if_absent(child_class) do
+            Concurrent::Map.new
+          end
+          per_class.compute_if_absent(parent_register) do
             _resolve_for_child_uncached(child_class, parent_register)
           end
         end

data/lib/lutaml/model/transformation_registry.rb

@@ -174,25 +174,31 @@ module Lutaml
       # @param register [Symbol, Register, nil] The register
       # @return [Mapping] The resolved mapping
       def get_or_build_mapping(model_class, format, register)
-        # Performance: Use fast array key instead of symbol construction
+        # Performance: nested class → format → register maps keyed on
+        # stable objects; the flat array key allocated per call.
         register_id = extract_register_id(register)
-        key = [model_class.object_id, format, register_id]
 
-        # Fast path: native Ruby uses Concurrent::Map, Opal uses Hash.
-        cached = @mappings[key]
+        per_class = @mappings[model_class]
+        per_format = per_class&.[](format)
+        cached = per_format&.[](register_id)
         return cached if cached
 
-        # Build mapping OUTSIDE any lock to avoid deadlock
-        # (ensure_mappings_imported! may recursively call get_or_build_mapping)
         mapping = model_class.mappings[format]
         mapping = mapping || model_class.default_mappings(format)
 
         mapping.ensure_mappings_imported!(register_id)
 
-        @mappings[key] = mapping
+        per_class = (@mappings[model_class] ||= new_inner_map)
+        (per_class[format] ||= new_inner_map)[register_id] = mapping
         mapping
       end
 
+      # Inner cache level container matching the outer map's engine
+      # (Concurrent::Map under GVL-threaded MRI, plain Hash under Opal).
+      def new_inner_map
+        Lutaml::Model.opal? ? {} : ::Concurrent::Map.new
+      end
+
       # Clear all cached data (transformations and mappings).
       #
       # This is useful for testing or when configuration changes dynamically.

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.34"
+    VERSION = "0.8.35"
   end
 end

data/lib/lutaml/xml/adapter_element.rb

@@ -64,8 +64,8 @@ module Lutaml
         name = adapter_class.name_of(node)
         super(
           node,
-          Hash(attributes),
-          Array(children),
+          attributes || NO_ATTRIBUTES,
+          children || NO_CHILDREN,
           text,
           name: name,
           parent_document: parent,
@@ -146,8 +146,19 @@ module Lutaml
         end
       end
 
+      # Shared frozen empties: the parse path hands these straight into
+      # XmlElement (which never mutates the containers it is given), so
+      # attribute-less elements — the majority in real documents — build
+      # nothing here.
+      NO_ATTRIBUTES = {}.freeze # rubocop:todo Lint/UselessConstantScoping
+      NO_CHILDREN = [].freeze # rubocop:todo Lint/UselessConstantScoping
+      EMPTY_ATTRIBUTES = [{}, nil].freeze # rubocop:todo Lint/UselessConstantScoping
+
       def node_attributes_with_order(node)
-        return [{}, nil] unless node.is_a?(Moxml::Element)
+        return EMPTY_ATTRIBUTES unless node.is_a?(Moxml::Element)
+
+        attrs = node.attributes
+        return EMPTY_ATTRIBUTES if attrs.respond_to?(:empty?) && attrs.empty?
 
         order = []
         hash = node.attributes.each_with_object({}) do |attr, h|
@@ -174,7 +185,7 @@ module Lutaml
       end
 
       def parse_children(node, default_namespace: nil)
-        return [] unless node.children
+        return NO_CHILDREN unless node.children
 
         # Non-element children (text/cdata/comment/PI) stay RAW moxml
         # nodes in the list — the hot scalar parse path reads text off
@@ -197,6 +208,8 @@ module Lutaml
       public
 
       def children
+        return @children if @children.empty?
+
         unless @non_element_children_wrapped
           @children.map! do |child|
             if child.is_a?(Moxml::Node) && !child.is_a?(Moxml::Element)

data/spec/benchmarks/xml_parsing_benchmark_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "benchmark/ips"
+
+# Adapter-comparison benchmark, runnable on demand:
+#   bundle exec rspec --tag benchmark spec/benchmarks/
+# Tagged out of the default suite (.rsex --tag ~benchmark); asserts
+# nothing about absolute speed — machines differ — but prints i/s and
+# allocations/op so regressions are visible when run deliberately.
+RSpec.describe "XML adapter benchmark", :benchmark do
+  Item = Class.new(Lutaml::Model::Serializable) do # rubocop:todo Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :tags, :string, collection: true
+
+    xml do
+      element "item"
+      map_attribute "id", to: :id
+      map_element "name", to: :name
+      map_element "tag", to: :tags
+    end
+  end
+
+  Root = Class.new(Lutaml::Model::Serializable) do # rubocop:todo Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    attribute :item, Item, collection: true
+
+    xml do
+      element "root"
+      map_element "item", to: :item
+    end
+  end
+
+  XML = +"<root>" # rubocop:todo Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+  1_000.times { |i| XML << %(<item id="#{i}"><name>Item #{i}</name><tag>a</tag><tag>b</tag></item>) }
+  XML << "</root>"
+
+  def allocations_of
+    GC.start
+    before = GC.stat(:total_allocated_objects)
+    yield
+    GC.stat(:total_allocated_objects) - before
+  end
+
+  %i[nokogiri ox oga rexml leptris].each do |adapter|
+    it "#{adapter}: from_xml/to_xml i/s and allocations" do
+      model = nil
+      Lutaml::Model::Config.with_adapter(xml: adapter) do
+        begin
+          Lutaml::Model::Config.adapter_for(:xml)
+        rescue Lutaml::Model::UnknownAdapterTypeError
+          skip "#{adapter} adapter unavailable on this platform"
+        end
+        report = Benchmark.ips(time: 2, warmup: 1, quiet: true) do |x|
+          x.report("parse") { model = Root.from_xml(XML) }
+          x.report("serialize") { model.to_xml }
+        end
+        parse_ips = report.entries.first.ips
+        serialize_ips = report.entries.last.ips
+
+        allocs = allocations_of { Root.from_xml(XML) }
+        puts format( # rubocop:todo RSpec/Output
+          "%<a>-9s parse %<p>7.1f i/s  serialize %<s>7.1f i/s  %<al>8d allocs/op",
+          a: adapter, p: parse_ips, s: serialize_ips, al: allocs,
+        )
+        expect(model.item.size).to eq(1_000)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.34
+  version: 0.8.35
 platform: ruby
 authors:
 - Ribose Inc.
@@ -971,6 +971,7 @@ files:
 - sig/lutaml/model.rbs
 - spec/address_person_spec.rb
 - spec/address_spec.rb
+- spec/benchmarks/xml_parsing_benchmark_spec.rb
 - spec/ceramic_spec.rb
 - spec/fixtures/address.rb
 - spec/fixtures/ceramic.rb