lutaml-model 0.8.23 → 0.8.28

data/lib/lutaml/xml/plan_serializer.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # Serialize-side mirror of the plan fast path: builds the output
+    # tree directly through leptris's fused create_child chain — no
+    # XmlElement tree, no DeclarationPlanner pass, no builder context
+    # stack, no moxml wrapper minting. Serialized shapes must be the
+    # plain ones (attributes, scalars, collections, nested models,
+    # raw fragments, content runs); custom-method, polymorphic,
+    # union, and multi-spelling rows keep the interpretive serializer
+    # (their output flows through hash-shaped custom APIs).
+    #
+    # Ordered/mixed models serialize from element_order when the
+    # instance carries one (parsed models): text runs, comments, and
+    # element entries in document order, mirroring the interpretive
+    # order applier — including its content-attr-first text reads
+    # (mutations to the model show up) and CDATA flattening. Models
+    # without element_order fall back interpretively (return nil).
+    module PlanSerializer
+      SERIALIZABLE_KINDS = %i[scalar collection_native collection_cb
+                              nested ordered_deferred raw content
+                              content_deferred].freeze
+      CONTENT_KINDS = %i[content content_deferred].freeze
+
+      class << self
+        # plan: the compiler's entry for instance's class
+        def call(instance, plan)
+          return nil if plan[:ordered] && instance.element_order.nil?
+
+          doc = ::Leptris::XML::Document.create
+          root = doc.create_element(plan[:tree][:name])
+          doc.root = root
+          if plan[:ordered]
+            build_ordered(root, instance, plan, doc)
+          else
+            build(root, instance, plan, doc)
+          end
+          doc.to_xml(indent: 2, no_decl: true)
+        end
+
+        # Whether the compiled plan is serialize-shaped. Ordered/mixed
+        # models serialize through build_ordered from element_order;
+        # plain models through plan rows.
+        def serializable?(plan)
+          plan[:rows].all? do |_rule, _attr, kind, _sp, _del|
+            SERIALIZABLE_KINDS.include?(kind)
+          end
+        end
+
+        private
+
+        def register
+          Lutaml::Model::Config.default_register
+        end
+
+        def build(element, instance, plan, doc)
+          write_attributes(element, instance, plan)
+          plan[:rows].each do |rule, attr, kind, spelling, delegate|
+            value = value_of(instance, attr, delegate)
+            next unless rule.render?(value, instance)
+
+            case kind
+            when :scalar
+              add_leaf(element, row_name(rule, spelling),
+                       attr.serialize(value, :xml, register), doc)
+            when :collection_native, :collection_cb
+              Array(value).each do |item|
+                add_leaf(element, rule.name.to_s,
+                         attr.serialize(item, :xml, register), doc)
+              end
+            when :nested, :ordered_deferred
+              Array(value).each do |item|
+                child_plan = PlanCompiler.compile(item.class, register)
+                child = element.create_child(child_plan[:tree][:name])
+                if child_plan[:ordered]
+                  return nil unless build_ordered(child, item, child_plan, doc)
+
+                else
+                  build(child, item, child_plan, doc)
+                end
+              end
+            when :raw
+              Array(value).each { |raw| element.add_child(raw.to_s) }
+            when :content, :content_deferred
+              Array(value).each { |run| element.add_child(doc.create_text_node(run.to_s)) }
+            end
+          end
+        end
+
+        # Element_order-driven emission (the interpretive order
+        # applier's contract): text runs and comments verbatim, each
+        # element entry consuming the next item of its collection
+        # (document order). Text reads prefer the content attribute
+        # when it lines up with the text-node count, so mutations to
+        # the model are reflected; element_order text is the fallback.
+        # PIs drop (interpretive parity). Returns nil when a nested
+        # ordered child lacks element_order (caller falls back).
+        def build_ordered(element, instance, plan, doc)
+          write_attributes(element, instance, plan)
+          rows_by_name = {}
+          plan[:rows].each do |rule, attr, kind, spelling, delegate|
+            next unless rule.name
+
+            rows_by_name[rule.name.to_s] ||= [rule, attr, kind, spelling,
+                                              delegate]
+          end
+          content_entry = plan[:rows].find do |rule, _attr, kind, _sp, _del|
+            CONTENT_KINDS.include?(kind) && rule.name.nil?
+          end
+          order = instance.element_order
+          element_indices = ::Hash.new(0)
+          content_attr = content_entry && content_entry[1]
+          content_value = content_attr &&
+            value_of(instance, content_attr, content_entry[4])
+          text_node_count = order.count { |o| o.type == "Text" }
+          use_content_index = content_value.is_a?(Array) &&
+            content_value.length == text_node_count
+          content_cdata = content_entry && content_entry[0].cdata
+          text_node_index = 0
+
+          order.each do |object|
+            case object.type
+            when "Text"
+              text = if content_attr && !content_value.nil?
+                       if use_content_index
+                         content_value[text_node_index].to_s
+                       elsif !content_value.is_a?(Array) && text_node_count <= 1
+                         content_value.to_s
+                       else
+                         object.text_content || object.name
+                       end
+                     else
+                       object.text_content || object.name
+                     end
+              text_node_index += 1
+              next if text.nil?
+              # Mixed content keeps whitespace; ordered-only skips it
+              next if content_attr.nil? && text.strip.empty?
+
+              element.add_child(content_cdata ? doc.create_cdata(text) : doc.create_text_node(text))
+            when "Comment"
+              element.add_child(doc.create_comment(object.text_content))
+            when "Element"
+              entry = rows_by_name[object.name]
+              next unless entry
+
+              _, attr, kind, _spelling, delegate = entry
+              value = value_of(instance, attr, delegate)
+              case kind
+              when :collection_native, :collection_cb
+                index = element_indices[object.name]
+                items = Array(value)
+                next unless index < items.length
+
+                element_indices[object.name] += 1
+                add_leaf(element, object.name,
+                         attr.serialize(items[index], :xml, register), doc)
+              when :nested, :ordered_deferred
+                item = if attr.collection?
+                         index = element_indices[object.name]
+                         element_indices[object.name] += 1
+                         Array(value)[index]
+                       else
+                         value
+                       end
+                next unless item
+
+                child_plan = PlanCompiler.compile(item.class, register)
+                child = element.create_child(child_plan[:tree][:name])
+                if child_plan[:ordered]
+                  return nil unless build_ordered(child, item, child_plan, doc)
+                else
+                  build(child, item, child_plan, doc)
+                end
+              when :raw
+                element.add_child(value.to_s) unless value.nil?
+              when :scalar
+                add_leaf(element, object.name,
+                         attr.serialize(value, :xml, register), doc)
+              end
+            end
+          end
+          true
+        end
+
+        # Attributes in document order when the instance recorded it
+        # (parsed models), else plan row order.
+        def write_attributes(element, instance, plan)
+          recorded = instance.attribute_order
+          if recorded && !recorded.empty?
+            by_name = {}
+            plan[:attr_rows].each do |rule, attr, _sp, delegate|
+              by_name[rule.name.to_s] = [rule, attr, delegate]
+            end
+            names = recorded |
+              plan[:attr_rows].map { |rule, _a, _s, _d| rule.name.to_s }
+            names.each do |name|
+              write_attribute(element, instance, name, by_name[name])
+            end
+          else
+            plan[:attr_rows].each do |rule, attr, _sp, delegate|
+              write_attribute(element, instance, rule.name.to_s,
+                              [rule, attr, delegate])
+            end
+          end
+        end
+
+        def write_attribute(element, instance, name, entry)
+          return unless entry
+
+          _rule, attr, delegate = entry
+          value = value_of(instance, attr, delegate)
+          return if value.nil?
+
+          element.set_attribute(name,
+                                attr.serialize(value, :xml, register).to_s)
+        end
+
+        def add_leaf(element, name, value, doc)
+          child = element.create_child(name)
+          child.add_child(doc.create_text_node(value.to_s)) unless value.nil?
+          child
+        end
+
+        def value_of(instance, attr, delegate)
+          if delegate
+            target = instance.public_send(delegate)
+            target&.public_send(attr.name)
+          else
+            instance.public_send(attr.name)
+          end
+        end
+
+        def row_name(rule, spelling)
+          (spelling || rule.name).to_s
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/plan_walk.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # Public consumer surface for the plan fast path: one engine
+    # parse + descriptor walk and direct model hydration, bypassing
+    # the wrapper-tree construction that dominates large-document
+    # consumer paths. The returned object is the mapped model root;
+    # collection attributes remain collections on that model.
+    module PlanWalk
+      class << self
+        # Build the plan, walk the document, and hydrate the mapped
+        # root. Returns nil when the model is not plan-compilable.
+        def call(model_class, xml, _options = {})
+          register = Lutaml::Model::Config.default_register
+          plan = PlanCompiler.compile(model_class, register)
+          return nil unless plan
+
+          document = ::Leptris::XML.parse(xml)
+          root = document.root
+          return nil unless root && root.name == plan[:tree][:name]
+
+          PlanHydrator.call(model_class, plan,
+                            plan[:descriptor].walk(root),
+                            node: root)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/transformation/custom_method_wrapper.rb

@@ -80,6 +80,14 @@ module Lutaml
         require "moxml" unless defined?(Moxml)
         fragment_doc = Moxml.new.parse(fragment_string, fragment: true)
         add_fragment_children_to_parent(fragment_doc, parent)
+      rescue Moxml::ParseError
+        # Engines without a fragment mode (leptris today, lutaml/moxml#188)
+        # reject multiple top-level nodes; re-parse under a synthetic root
+        # and lift its children.
+        wrapped = Moxml.new.parse(
+          "<lutaml-fragment>#{fragment_string}</lutaml-fragment>",
+        )
+        add_fragment_children_to_parent(wrapped.root, parent)
       rescue LoadError
         append_raw_content(parent, fragment_string)
       end

data/lib/lutaml/xml/xml_element.rb

@@ -299,7 +299,7 @@ module Lutaml
       end
 
       def text
-        return @text if children.empty?
+        return @text if @children.empty?
         return @computed_text if defined?(@computed_text)
 
         @computed_text = if content_bearing_children_count > 1
@@ -393,7 +393,11 @@ module Lutaml
 
         @children_index = {}
         @children.each do |child|
-          next if child.is_a?(XmlElement) && child.processing_instruction?
+          # Index element children only: the index serves by-name element
+          # lookup, and AdapterElement keeps non-element children raw
+          # (lazily wrapped) until #children is read.
+          next unless child.is_a?(XmlElement)
+          next if child.processing_instruction?
 
           key = child.namespaced_name
           @children_index[key] ||= []

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "standard_adapter"
+
+module Lutaml
+  module Yaml
+    module Adapter
+      # YAML over the yeptris engine (libyeptris C11). Uses the native
+      # Yeptris::YAML surface, which does not rebind or interact with the
+      # Psych constant, so it coexists with the standard adapter in one
+      # process. Inherits the document/generation contract; only the
+      # engine calls differ.
+      #
+      # Semantic notes vs the standard adapter's Psych.safe_load:
+      # implicit typing is parity-verified (compat_11 schema); anchors
+      # and aliases always resolve; a tagged value without a core type
+      # materializes as plain data instead of raising DisallowedClass.
+      class YeptrisAdapter < StandardAdapter
+        # yeptris is required lazily: the ruby-platform variant installs
+        # everywhere but only loads where libyeptris exists (no Windows
+        # prebuilts) — a broken install must degrade to detection
+        # fallback, never crash loads.
+        def self.parse(yaml, _options = {})
+          require "yeptris"
+          require "yeptris/yaml"
+          # rubocop:disable-next Naming/VariableNumber -- upstream schema literal
+          Yeptris::YAML.load(yaml, schema: :compat_11)
+        end
+
+        def to_yaml(_options = {})
+          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
+                                      # Unwrap __root__ wrapper to get actual content
+                                      @attributes.to_hash["__root__"]
+                                    else
+                                      # Legacy Hash input (backward compatibility)
+                                      @attributes
+                                    end
+
+          require "yeptris"
+          require "yeptris/yaml"
+          Yeptris::YAML.dump(attributes_to_serialize)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/yaml/adapter.rb

@@ -8,6 +8,11 @@ module Lutaml
       autoload :MappingRule, "#{__dir__}/adapter/mapping_rule"
       autoload :Transform, "#{__dir__}/adapter/transform"
       autoload :StandardAdapter, "#{__dir__}/adapter/standard_adapter"
+      # MRI-only native engine adapter (libyeptris FFI)
+      Lutaml::Model::RuntimeCompatibility.autoload_native(
+        self,
+        YeptrisAdapter: "#{__dir__}/adapter/yeptris_adapter",
+      )
     end
   end
 end

data/lib/lutaml/yaml/format.rb

@@ -21,7 +21,7 @@ Lutaml::Model::FormatRegistry.register(
   transformer: Lutaml::Yaml::Adapter::Transform,
   key_value: true,
   adapter_options: {
-    available: %i[standard standard_yaml],
+    available: %i[standard standard_yaml yeptris],
     default: :standard,
   },
 )

data/lib/tasks/performance.rake

@@ -63,6 +63,11 @@ namespace :performance do
     run_bench("#{BENCH_DIR}/bench_unitsml.rb")
   end
 
+  desc "XML model-pipeline performance probe (from_xml/to_xml i/s + allocs)"
+  task :probe_xml do
+    require_relative "performance_probe_xml"
+  end
+
   # --- Gate comparison ---
 
   desc "Compare downstream benchmark JSON results (gate enforcement)"

data/lib/tasks/performance_comparator.rb

@@ -12,9 +12,9 @@ class PerformanceComparator
 
   BENCHMARK_MATRIX = {
     xml: %i[nokogiri ox oga rexml],
-    json: %i[standard_json multi_json oj],
-    yaml: %i[standard_yaml],
-    toml: %i[toml_rb tomlib],
+    json: %i[standard_json multi_json oj yeptris],
+    yaml: %i[standard_yaml yeptris],
+    toml: %i[toml_rb tomlib teptris],
   }.freeze
 
   DIRECTIONS = %i[from to].freeze
@@ -107,8 +107,24 @@ class PerformanceComparator
     in [:toml, :tomlib]
       # Skip tomlib on Windows due to segmentation fault issues
       Gem.win_platform?
+    in [:yaml | :json, :yeptris]
+      # yeptris ships prebuilt platform gems for linux/darwin only
+      Gem.win_platform?
+    in [:toml, :teptris]
+      teptris_loadable?
     else
       false
     end
   end
+
+  # A teptris platform gem whose native library cannot load (the 0.2.17/
+  # 0.2.18 x86_64-linux/x64-mingw-ucrt soname gap) must skip its cell,
+  # not crash the comparator run.
+  def teptris_loadable?
+    require "teptris"
+    false
+  rescue LoadError, StandardError
+    warn "performance comparator: teptris not loadable here — skipping its cell"
+    true
+  end
 end

data/lib/tasks/performance_probe.rake

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# One-command performance probe for the model pipeline (TODO.perf/01).
+#
+#   rake performance:probe            # steady-state i/s + allocations/op
+#   rake performance:profile          # ruby-prof flat profiles (parse + dump)
+#   rake performance:oneshot          # fresh-process boot+parse-once medians
+desc "Performance probes for the model pipeline"
+namespace :performance do
+  desc "steady-state i/s and allocations per op (nested 200-item model)"
+  task :probe do
+    system({ "BENCH_DIR" => nil }, Gem.ruby, File.expand_path("performance_probe.rb", __dir__), "probe") || raise("probe failed")
+  end
+
+  desc "ruby-prof flat profiles for from_yaml and to_yaml"
+  task :profile do
+    system(Gem.ruby, File.expand_path("performance_probe.rb", __dir__), "profile") || raise("profile failed")
+  end
+
+  desc "one-shot (fresh process) boot+define and parse-once medians"
+  task :oneshot do
+    boots = []
+    parses = []
+    5.times do
+      out = `#{Gem.ruby} #{File.expand_path("performance_probe.rb", __dir__)} oneshot`
+      boots << Regexp.last_match(1).to_f if out =~ /boot\+define: ([\d.]+)ms/
+      parses << Regexp.last_match(1).to_f if out =~ /parse-once: ([\d.]+)ms/
+    end
+    med = ->(a) { a.sort[a.length / 2] }
+    puts format("boot+define median: %<boot>.1fms   parse-once median: %<parse>.1fms",
+                boot: med.call(boots), parse: med.call(parses)) + " (#{boots.length} runs)" 
+  end
+end

data/lib/tasks/performance_probe.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Model-pipeline performance probe (TODO.perf/01). Run via
+# rake performance:probe / :profile / :oneshot, or directly:
+#   ruby lib/tasks/performance_probe.rb probe|profile|oneshot
+
+MODE = ARGV[0] || "probe"
+
+# One-shot mode times the require itself; every other mode needs it up front.
+require "lutaml/model" unless MODE == "oneshot"
+
+def define_models
+  item = Class.new(Lutaml::Model::Serializable) do
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :tags, :string, collection: true
+
+    key_value do
+      map "id", to: :id
+      map "name", to: :name
+      map "tags", to: :tags
+    end
+  end
+  root = Class.new(Lutaml::Model::Serializable) do
+    attribute :item, item, collection: true
+
+    key_value { map "item", to: :item }
+  end
+  [item, root]
+end
+
+def build_root(item, root, count)
+  root.new(item: (0...count).map { |i| item.new(id: i, name: "Test #{i}", tags: %w[a b c]) })
+end
+
+def ips_of(seconds = 3)
+  require "benchmark/ips"
+  lambda do |label, &blk|
+    r = Benchmark.ips(time: seconds, quiet: true) { |x| x.report(label, &blk) }
+    r.entries.max_by(&:ips).ips.round(1)
+  end
+end
+
+def allocs_of(&blk)
+  GC.start
+  before = GC.stat(:total_allocated_objects)
+  50.times(&blk)
+  (GC.stat(:total_allocated_objects) - before) / 50.0
+end
+
+case MODE
+when "probe"
+  item, root = define_models
+  model = build_root(item, root, 200)
+  yaml_doc = model.to_yaml
+  json_doc = model.to_json
+  root.from_yaml(yaml_doc)
+
+  ips = ips_of
+  puts format("%<label>s: %<ips>8.1f i/s   allocs/op: %<allocs>8.1f",
+              label: "from_yaml",
+              ips: ips.call("fy") { root.from_yaml(yaml_doc) },
+              allocs: allocs_of { root.from_yaml(yaml_doc) })
+  puts format("%<label>s: %<ips>8.1f i/s   allocs/op: %<allocs>8.1f",
+              label: "to_yaml  ",
+              ips: ips.call("ty") { model.to_yaml },
+              allocs: allocs_of { model.to_yaml })
+  puts format("%<label>s: %<ips>8.1f i/s   allocs/op: %<allocs>8.1f",
+              label: "from_json",
+              ips: ips.call("fj") { root.from_json(json_doc) },
+              allocs: allocs_of { root.from_json(json_doc) })
+  puts format("%<label>s: %<ips>8.1f i/s   allocs/op: %<allocs>8.1f",
+              label: "to_json  ",
+              ips: ips.call("tj") { model.to_json },
+              allocs: allocs_of { model.to_json })
+when "profile"
+  item, root = define_models
+  model = build_root(item, root, 200)
+  yaml_doc = model.to_yaml
+  root.from_yaml(yaml_doc)
+
+  require "ruby-prof"
+  def print_profile(profile, label)
+    puts "===== #{label} (20 iterations, self-time) ====="
+    printer = RubyProf::FlatPrinter.new(profile)
+    begin
+      printer.print($stdout, {})
+    rescue ArgumentError
+      printer.print($stdout)
+    end
+  end
+
+  print_profile(RubyProf::Profile.profile { 20.times { root.from_yaml(yaml_doc) } }, "from_yaml")
+  print_profile(RubyProf::Profile.profile { 20.times { model.to_yaml } }, "to_yaml")
+when "oneshot"
+  # Fresh-process mode: this script IS the one-shot body; the rake task
+  # re-invokes it N times and reports medians.
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  require "lutaml/model"
+  item, root = define_models
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  yaml_doc = build_root(item, root, 200).to_yaml
+  root.from_yaml(yaml_doc)
+  t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  puts format("boot+define: %<boot>.1fms  parse-once: %<parse>.1fms", boot: (t1 - t0) * 1000, parse: (t2 - t1) * 1000)
+end

data/lib/tasks/performance_probe_plan_walk.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "leptris"
+require "leptris/xml/descriptor"
+require "benchmark"
+
+module PlanWalkProbe
+  class BulkItem < Lutaml::Model::Serializable
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :tags, :string, collection: true
+
+    xml do
+      element "row"
+      map_attribute "id", to: :id
+      map_element "name", to: :name
+      map_element "tags", to: :tags
+    end
+  end
+
+  class BulkRoot < Lutaml::Model::Serializable
+    attribute :item, BulkItem, collection: true
+
+    xml do
+      element "iso"
+      map_element "row", to: :item
+    end
+  end
+end
+
+xml = File.read("/tmp/iso.xml")
+Lutaml::Model::Config.adapter_for(:xml) # resolve adapter before benchmarking
+
+measure = lambda do |label, &block|
+  elapsed = Benchmark.measure { 3.times(&block) }.real * 1000
+  puts "#{label}: %.2f ms total / %.2f ms each" % [elapsed, elapsed / 3]
+end
+
+measure.call("raw parse + descriptor walk") do
+  descriptor = Leptris::XML::Descriptor.build(
+    name: "iso",
+    children: [{ name: "row", kind: :collection }],
+  )
+  descriptor.walk(Leptris::XML.parse(xml).root)
+end
+
+Lutaml::Model::Config.instance.xml_plan_fast_path = true
+measure.call("PlanWalk parse + 5000 model.new") do
+  result = Lutaml::Xml::PlanWalk.call(PlanWalkProbe::BulkRoot, xml)
+  raise "PlanWalk returned nil" unless result&.item&.size == 5000
+end
+
+Lutaml::Model::Config.instance.xml_plan_fast_path = false
+measure.call("interpretive from_xml") do
+  result = PlanWalkProbe::BulkRoot.from_xml(xml)
+  raise "interpretive returned wrong size" unless result.item.size == 5000
+end

data/lib/tasks/performance_probe_xml.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# XML pipeline probe (mirrors performance_probe.rb's KV shape): quantifies
+# the lutaml-model XML layer over the moxml runtime-default engine.
+#   ruby lib/tasks/performance_probe.rb xml
+
+require "lutaml/model"
+
+item = Class.new(Lutaml::Model::Serializable) do
+  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
+  attribute :item, item, collection: true
+
+  xml do
+    element "root"
+    map_element "item", to: :item
+  end
+end
+
+model = root.new(item: (0...200).map { |i| item.new(id: i, name: "Test #{i}", tags: %w[a b c]) })
+xml_doc = model.to_xml
+root.from_xml(xml_doc)
+
+ips = lambda do |label, &blk|
+  require "benchmark/ips"
+  r = Benchmark.ips(time: 3, quiet: true) { |x| x.report(label, &blk) }
+  r.entries.max_by(&:ips).ips.round(1)
+end
+
+allocs = lambda do |&blk|
+  GC.start
+  before = GC.stat(:total_allocated_objects)
+  50.times(&blk)
+  (GC.stat(:total_allocated_objects) - before) / 50.0
+end
+
+fy = ips.call("fx") { root.from_xml(xml_doc) }
+fa = allocs.call { root.from_xml(xml_doc) }
+ty = ips.call("tx") { model.to_xml }
+ta = allocs.call { model.to_xml }
+
+puts format("from_xml: %<ips>8.1f i/s   allocs/op: %<allocs>8.1f", ips: fy, allocs: fa)
+puts format("to_xml  : %<ips>8.1f i/s   allocs/op: %<allocs>8.1f", ips: ty, allocs: ta)
+puts "engine: #{Moxml::VERSION} / #{Leptris::VERSION}"