lutaml-model 0.7.6 → 0.8.0

data/RELEASE_NOTES.adoc

@@ -6,6 +6,57 @@ This release introduces significant enhancements to the lutaml-model library, fo
 
 == Key changes
 
+=== XML namespace_scope directive (v0.8.0+)
+
+**NEW**: Complete implementation of the `namespace_scope` directive for controlling XML namespace hoisting and consolidation.
+
+The `namespace_scope` directive allows you to control WHERE namespace declarations appear in serialized XML, enabling cleaner output for multi-namespace documents.
+
+**Key Features:**
+
+* **Namespace consolidation**: Hoist multiple namespaces to root element
+* **Declaration control**: Per-namespace `:auto`, `:always`, `:never` modes
+* **Child inheritance**: W3C-compliant namespace inheritance (no duplicate declarations)
+* **Type namespace support**: Automatic handling of Type-level namespaces
+* **Format preservation**: Round-trip serialization preserves input format exactly
+
+==== Basic Usage
+
+[source,ruby]
+----
+class Vcard < Lutaml::Model::Serializable
+  xml do
+    root "vCard"
+    namespace VcardNamespace
+
+    # Consolidate namespaces at root
+    namespace_scope [
+      { namespace: DcNamespace, declare: :always },
+      { namespace: DctermsNamespace, declare: :auto }
+    ]
+  end
+end
+----
+
+==== Child Inheritance Behavior
+
+Children in the same namespace as their parent now correctly inherit the parent's namespace without redeclaration:
+
+[source,xml]
+----
+<vCard xmlns="urn:ietf:params:xml:ns:vcard-4.0"
+       xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <version>4.0</version>  <!-- Inherits default namespace -->
+  <contact>
+    <dc:title>Dr. John Doe</dc:title>  <!-- Uses parent's dc: prefix -->
+  </contact>
+</vCard>
+----
+
+==== Comprehensive Documentation
+
+For complete information including W3C compliance, Type namespace interaction, and multi-namespace examples, see link:docs/namespace-management.adoc[XML Namespace Management Guide].
+
 === Missing values handling family
 
 A comprehensive set of features for handling the "missing values" family (empty,

data/Rakefile

@@ -9,4 +9,6 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
+Dir.glob("lib/tasks/**/*.rake").each { |r| load r }
+
 task default: %i[spec rubocop]

data/bench/bench_all.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run all downstream benchmarks sequentially
+#
+# Usage:
+#   bundle exec ruby tmp/bench/bench_all.rb
+#   BENCH_JSON=/tmp/bench_current.json ITERATIONS=5 bundle exec ruby tmp/bench/bench_all.rb
+#
+# GHA example:
+#   XMI_DIR=$GITHUB_WORKSPACE/xmi STS_DIR=$GITHUB_WORKSPACE/sts-ruby \
+#     MML_DIR=$GITHUB_WORKSPACE/mml UNIWORD_DIR=$GITHUB_WORKSPACE/uniword \
+#     BENCH_JSON=/tmp/bench_current.json ITERATIONS=3 \
+#     bundle exec ruby tmp/bench/bench_all.rb
+
+bench_dir = File.dirname(__FILE__)
+
+# Targets that run from the lutaml-model bundle
+local_targets = %w[xmi sts mml uniword]
+
+# Targets that need their own bundle (different gem dependencies)
+remote_targets = %w[niso unitsml]
+
+puts "Running benchmarks from lutaml-model bundle"
+puts "=" * 90
+
+local_targets.each do |target|
+  script = File.join(bench_dir, "bench_#{target}.rb")
+  if File.exist?(script)
+    puts
+    system("bundle exec ruby #{script}")
+  else
+    puts "SKIP #{target}: #{script} not found"
+  end
+end
+
+unless remote_targets.empty?
+  puts
+  puts "=" * 90
+  puts "Note: The following require their own bundle (run separately):"
+  remote_targets.each do |target|
+    script = File.join(bench_dir, "bench_#{target}.rb")
+    puts "  #{target}: #{script}" if File.exist?(script)
+  end
+  puts
+  puts "  NISO JATS: cd $NISO_DIR && bundle exec ruby #{bench_dir}/bench_niso.rb"
+  puts "  Unitsml:   cd $UNITSML_DIR && bundle exec ruby #{bench_dir}/bench_unitsml.rb"
+end
+
+puts
+puts "=" * 90
+puts "All local benchmarks complete."

data/bench/bench_common.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# Shared benchmark infrastructure for lutaml-model performance testing.
+# Each bench_*.rb script requires this file.
+#
+# Usage:
+#   bundle exec ruby bench/bench_xmi.rb
+#   bundle exec ruby bench/bench_niso.rb
+#   bundle exec ruby bench/bench_sts.rb
+#   bundle exec ruby bench/bench_mml.rb
+#   bundle exec ruby bench/bench_unitsml.rb
+#   bundle exec ruby bench/bench_uniword.rb
+
+require "bundler/setup"
+require "benchmark"
+require "fileutils"
+
+module BenchCommon
+  ITERATIONS = (ENV["ITERATIONS"] || "3").to_i
+  WARMUP_ITERATIONS = 1
+
+  module_function
+
+  # Measure parse time and allocations for a block
+  def measure(name, iterations: ITERATIONS, &)
+    # Warmup
+    WARMUP_ITERATIONS.times(&)
+
+    times = []
+    allocations = []
+    iterations.times do
+      GC.start
+      GC.disable
+      mem_before = ObjectSpace.count_objects[:TOTAL]
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      GC.enable
+      mem_after = ObjectSpace.count_objects[:TOTAL]
+      times << (t1 - t0)
+      allocations << (mem_after - mem_before)
+    end
+
+    avg_time = times.sum / times.size
+    min_time = times.min
+    max_time = times.max
+    avg_alloc = (allocations.sum / allocations.size).round
+    ips = 1.0 / avg_time
+
+    printf "  %-55s %6.3fs (min: %.3f, max: %.3f)  %9d allocs  %6.1f IPS\n",
+           name, avg_time, min_time, max_time, avg_alloc, ips
+
+    {
+      name: name,
+      avg_time: avg_time,
+      min_time: min_time,
+      max_time: max_time,
+      allocations: avg_alloc,
+      ips: ips,
+    }
+  end
+
+  # Run stackprof allocation profile and print top N methods
+  def stackprof_top(name, top_n: 25, iterations: 10, &block)
+    require "stackprof"
+
+    dump_path = "/tmp/lutaml_bench_#{name}.dump"
+    StackProf.run(mode: :object, out: dump_path, raw: true) do
+      iterations.times(&block)
+    end
+
+    report = StackProf::Report.from_file(dump_path)
+    total = report.data[:samples] || 0
+
+    puts "\n  Stackprof Object Allocation Profile (#{name})"
+    puts "  Total allocations: #{total}"
+    puts "  #{'-' * 80}"
+    printf "  %8s %6s  %s\n", "Allocs", "%", "Method"
+    puts "  #{'-' * 80}"
+
+    report.data[:frames]
+      .sort_by { |_, v| -(v[:samples] || 0) }
+      .first(top_n)
+      .each_value do |v|
+        samples = v[:samples] || 0
+        pct = (samples.to_f / total * 100).round(1)
+        printf "  %8d %5.1f%%  %s\n", samples, pct, v[:name]
+      end
+
+    { total: total, dump_path: dump_path }
+  end
+
+  # Print a summary comparison between two result sets
+  def print_comparison(label, before, after)
+    delta_time = ((after[:avg_time] - before[:avg_time]) / before[:avg_time] * 100).round(1)
+    delta_alloc = if before[:allocations].positive?
+                    ((after[:allocations] - before[:allocations]).to_f / before[:allocations] * 100).round(1)
+                  else
+                    "N/A"
+                  end
+    delta_ips = ((after[:ips] - before[:ips]) / before[:ips] * 100).round(1)
+    printf "\n  %-30s %+.1f%% time  %s%% allocs  %+.1f%% IPS\n",
+           label, delta_time, delta_alloc, delta_ips
+  end
+
+  def print_header(title)
+    puts "=" * 90
+    puts title
+    puts "=" * 90
+    puts "Ruby #{RUBY_VERSION} / #{RUBY_PLATFORM} / #{RUBY_RELEASE_DATE}"
+    puts "Iterations: #{ITERATIONS}"
+    puts
+  end
+
+  # Write benchmark results to a JSON file for later comparison.
+  # Each entry keyed by fixture label.
+  def write_results_json(path, results)
+    require "json"
+    data = results.transform_values do |r|
+      {
+        avg_time: r[:avg_time],
+        min_time: r[:min_time],
+        max_time: r[:max_time],
+        allocations: r[:allocations],
+        ips: r[:ips],
+      }
+    end
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, "#{JSON.pretty_generate(data)}\n")
+    puts "  Results written to #{path}"
+  end
+
+  # Load benchmark results from a JSON file.
+  def load_results_json(path)
+    require "json"
+    JSON.parse(File.read(path), symbolize_names: true)
+  end
+
+  # JSON output path from --json-output=FILE or BENCH_JSON env var
+  def json_output_path
+    default = ENV.fetch("BENCH_JSON", nil)
+    ARGV.each do |arg|
+      default = $1 if arg =~ /--json-output=(.+)/
+    end
+    default
+  end
+end

data/bench/bench_compare.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Paired A/B benchmark comparison for downstream fixtures.
+#
+# Compares benchmark results between two JSON result files (base vs current)
+# using three gate layers:
+#   1. Allocation ratio gate  — current_allocs / base_allocs ≤ threshold
+#   2. Min-time ratio gate    — min_time(current) / min_time(base) ≤ threshold
+#   3. Absolute time gate     — min_time(current) ≤ per-fixture limit
+#
+# Usage:
+#   # Generate base results (on main branch):
+#   BENCH_JSON=/tmp/bench_base.json bundle exec ruby tmp/bench/bench_xmi.rb
+#
+#   # Generate current results (on feature branch):
+#   BENCH_JSON=/tmp/bench_current.json bundle exec ruby tmp/bench/bench_xmi.rb
+#
+#   # Compare:
+#   bundle exec ruby tmp/bench/bench_compare.rb /tmp/bench_base.json /tmp/bench_current.json
+#
+# Exit code: 0 if all gates pass, 1 if any gate fails.
+
+require_relative "gate_config"
+require "json"
+
+module BenchCompare
+  module_function
+
+  def run(base_path, current_path)
+    base = load_results(base_path)
+    current = load_results(current_path)
+
+    puts "=" * 90
+    puts "Benchmark Gate Comparison"
+    puts "=" * 90
+    puts "Base:    #{base_path}"
+    puts "Current: #{current_path}"
+    puts
+
+    # Find common fixtures
+    common_labels = base.keys & current.keys
+    if common_labels.empty?
+      if base.empty? && current.empty?
+        puts "WARNING: No benchmark results in either base or current (all fixtures skipped?)."
+        puts "Skipping gate comparison."
+        exit 0
+      else
+        warn "ERROR: No common fixtures found between base and current results."
+        warn "  Base fixtures:    #{base.keys.join(', ')}"
+        warn "  Current fixtures: #{current.keys.join(', ')}"
+        exit 1
+      end
+    end
+
+    any_failure = false
+    results = []
+    registered_labels = GateConfig.all_gate_labels
+
+    common_labels.sort.each do |label|
+      b = base[label]
+      c = current[label]
+      gate = GateConfig.find_gate(label.to_s)
+
+      # Only enforce gates on registered fixtures; others are informational
+      enforce = registered_labels.include?(label.to_s)
+
+      result = check_gates(label, b, c, gate, enforce: enforce)
+      results << result
+      any_failure = true if result[:failed]
+      print_gate_result(result)
+    end
+
+    # Report fixtures only in one side
+    only_base = base.keys - current.keys
+    only_current = current.keys - base.keys
+    if only_base.any?
+      puts "\n  WARNING: Fixtures only in base: #{only_base.join(', ')}"
+    end
+    if only_current.any?
+      puts "\n  WARNING: Fixtures only in current: #{only_current.join(', ')}"
+    end
+
+    puts
+    puts "=" * 90
+    summary = results.select { |r| r[:failed] }
+    if summary.empty?
+      puts "ALL GATES PASSED (#{results.size} fixtures)"
+    else
+      puts "GATES FAILED: #{summary.size}/#{results.size} fixtures"
+      summary.each do |r|
+        puts "  - #{r[:label]}: #{r[:failures].join(', ')}"
+      end
+    end
+    puts "=" * 90
+
+    exit(1) if any_failure
+  end
+
+  def check_gates(label, base, current, gate, enforce: true)
+    failures = []
+
+    # Gate 1: Allocation ratio
+    alloc_ratio = if base[:allocations].positive?
+                    current[:allocations].to_f / base[:allocations]
+                  else
+                    0.0
+                  end
+    threshold = gate[:alloc_ratio] || GateConfig::DEFAULT_ALLOC_RATIO
+    if alloc_ratio > threshold
+      failures << "alloc_ratio: #{format('%.4f', alloc_ratio)} > #{threshold}"
+    end
+
+    # Gate 2: Min-time ratio
+    time_ratio = if base[:min_time].positive?
+                   current[:min_time].to_f / base[:min_time]
+                 else
+                   0.0
+                 end
+    threshold = gate[:time_ratio] || GateConfig::DEFAULT_TIME_RATIO
+    if time_ratio > threshold
+      failures << "time_ratio: #{format('%.4f', time_ratio)} > #{threshold}"
+    end
+
+    # Gate 3: Absolute time
+    abs_limit = gate[:absolute_max]
+    if abs_limit && current[:min_time] > abs_limit
+      failures << "absolute: #{format('%.3f',
+                                      current[:min_time])}s > #{abs_limit}s"
+    end
+
+    # Unregistered fixtures: report but don't enforce
+    violations = failures.dup
+    failures = [] unless enforce
+
+    {
+      label: label,
+      base_time: base[:min_time],
+      current_time: current[:min_time],
+      base_allocs: base[:allocations],
+      current_allocs: current[:allocations],
+      alloc_ratio: alloc_ratio,
+      time_ratio: time_ratio,
+      failures: failures,
+      violations: violations,
+      failed: enforce && violations.any?,
+      enforced: enforce,
+    }
+  end
+
+  def print_gate_result(result)
+    status = if result[:enforced]
+               result[:failed] ? "FAIL" : "PASS"
+             else
+               "INFO"
+             end
+    label = result[:label]
+
+    printf "  %-25s [%s]\n", label, status
+    printf "    time:   %.3fs → %.3fs  (ratio: %.3f)\n",
+           result[:base_time], result[:current_time], result[:time_ratio]
+    printf "    allocs: %d → %d  (ratio: %.4f)\n",
+           result[:base_allocs], result[:current_allocs], result[:alloc_ratio]
+
+    (result[:enforced] ? result[:failures] : result[:violations]).each do |f|
+      prefix = result[:enforced] ? ">>>" : "note:"
+      printf "    %s %s\n", prefix, f
+    end
+    puts
+  end
+
+  def load_results(path)
+    unless File.exist?(path)
+      warn "ERROR: Results file not found: #{path}"
+      exit 1
+    end
+
+    raw = JSON.parse(File.read(path), symbolize_names: true)
+    # Normalize symbol/string keys — JSON keys come as strings
+    raw.each_with_object({}) do |(k, v), h|
+      h[k.to_s] = v
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.length < 2
+    warn "Usage: #{$PROGRAM_NAME} <base_results.json> <current_results.json>"
+    warn ""
+    warn "Generate result files with: BENCH_JSON=/tmp/results.json bundle exec ruby tmp/bench/bench_xmi.rb"
+    exit 1
+  end
+
+  BenchCompare.run(ARGV[0], ARGV[1])
+end

data/bench/bench_mml.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Benchmark: Plurimath MML (MathML parsing)
+# Gate: parse time < 1.5s for complex3-567KB
+#
+# Usage:
+#   MML_DIR=/path/to/mml ITERATIONS=5 bundle exec ruby tmp/bench/bench_mml.rb
+#   BENCH_JSON=/tmp/results.json bundle exec ruby tmp/bench/bench_mml.rb
+
+require_relative "bench_common"
+include BenchCommon
+
+print_header("Plurimath MML Benchmark — MathML parsing")
+
+mml_root = ENV["MML_DIR"] || "/Users/mulgogi/src/plurimath/mml"
+$LOAD_PATH.unshift("#{mml_root}/lib")
+require "mml"
+
+mml_files = [
+  ["simple-1KB",
+   "#{mml_root}/spec/fixtures/mml2-testsuite/testsuite/Presentation/TokenElements/mi/mi.xml"],
+  ["complex1-46KB",
+   "#{mml_root}/spec/fixtures/mml2-testsuite/testsuite/TortureTests/Complexity/complex1.xml"],
+  ["complex4-50KB",
+   "#{mml_root}/spec/fixtures/mml2-testsuite/testsuite/TortureTests/Complexity/complex4.xml"],
+  ["size1000-245KB",
+   "#{mml_root}/spec/fixtures/mml2-testsuite/testsuite/TortureTests/Size/1000.xml"],
+  ["complex3-567KB",
+   "#{mml_root}/spec/fixtures/mml2-testsuite/testsuite/TortureTests/Complexity/complex3.xml"],
+]
+
+results = {}
+mml_files.each do |label, path|
+  unless File.exist?(path)
+    puts "  SKIP #{label}: #{path} not found"
+    next
+  end
+  xml = File.read(path)
+  size_kb = File.size(path) / 1024.0
+  results[label] = measure("MML #{label} (#{size_kb.round(0)}KB)") do
+    Mml.parse(xml)
+  end
+end
+
+puts "\n  Gate checks:"
+if results["complex3-567KB"]
+  status = results["complex3-567KB"][:avg_time] < 1.5 ? "PASS" : "FAIL"
+  printf "  complex3-567KB < 1.5s: %s (%.3fs)\n", status,
+         results["complex3-567KB"][:avg_time]
+end
+
+write_results_json(json_output_path, results) if json_output_path

data/bench/bench_niso.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Benchmark: NISO JATS (Journal Article parsing)
+# Gate: parse time < 0.40s for pnas-152KB
+#
+# Usage:
+#   NISO_DIR=/path/to/niso-jats ITERATIONS=5 bundle exec ruby bench/bench_niso.rb
+#   BENCH_JSON=/tmp/results.json bundle exec ruby bench/bench_niso.rb
+#
+# NOTE: Must run from the niso-jats bundle:
+#   cd $NISO_DIR && bundle exec ruby /path/to/lutaml-model/bench/bench_niso.rb
+
+lutaml_model_root = ENV["LUTAML_MODEL_DIR"] || "/Users/mulgogi/src/lutaml/lutaml-model"
+require "#{lutaml_model_root}/bench/bench_common"
+include BenchCommon
+
+print_header("NISO JATS Benchmark — Journal Article parsing")
+
+niso_root = ENV["NISO_DIR"] || "/Users/mulgogi/src/mn/niso-jats"
+$LOAD_PATH.unshift("#{niso_root}/lib")
+require "niso/jats"
+
+niso_files = [
+  ["metrology-4KB",  "#{niso_root}/spec/fixtures/metrologia/metv9i4p155.xml"],
+  ["bmj-49KB",       "#{niso_root}/spec/fixtures/bmj_sample.xml"],
+  ["elementa-115KB",
+   "#{niso_root}/spec/fixtures/niso-jats/publishing/1.1d3/Smallsamples/journal.elementa.000012.xml"],
+  ["elementa-125KB",
+   "#{niso_root}/spec/fixtures/niso-jats/publishing/1.1d3/Smallsamples/journal.elementa.000017.xml"],
+  ["pnas-152KB", "#{niso_root}/spec/fixtures/pnas_sample.xml"],
+]
+
+results = {}
+niso_files.each do |label, path|
+  unless File.exist?(path)
+    puts "  SKIP #{label}: #{path} not found"
+    next
+  end
+  xml = File.read(path)
+  size_kb = File.size(path) / 1024.0
+  results[label] = measure("JATS #{label} (#{size_kb.round(0)}KB)") do
+    Niso::Jats::Article.from_xml(xml)
+  end
+end
+
+puts "\n  Gate checks:"
+if results["pnas-152KB"]
+  status = results["pnas-152KB"][:avg_time] < 0.25 ? "PASS" : "FAIL"
+  printf "  pnas-152KB < 0.25s: %s (%.3fs)\n", status,
+         results["pnas-152KB"][:avg_time]
+end
+
+write_results_json(json_output_path, results) if json_output_path

data/bench/bench_sts.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Benchmark: STS Ruby (ISO/NISO STS document parsing)
+# Gate: parse time < 2.0s for ISO-13849-1MB
+#
+# Usage:
+#   STS_DIR=/path/to/sts-ruby ITERATIONS=5 bundle exec ruby tmp/bench/bench_sts.rb
+#   BENCH_JSON=/tmp/results.json bundle exec ruby tmp/bench/bench_sts.rb
+
+require_relative "bench_common"
+include BenchCommon
+
+print_header("STS Ruby Benchmark — ISO/NISO STS document parsing")
+
+sts_root = ENV["STS_DIR"] || "/Users/mulgogi/src/mn/sts-ruby"
+$LOAD_PATH.unshift("#{sts_root}/lib")
+require "sts"
+
+sts_files = [
+  ["feature-doc-23KB",  "#{sts_root}/spec/fixtures/iso_sts/feature_doc.xml"],
+  ["tbx-nisosts-101KB", "#{sts_root}/spec/fixtures/tbx-nisosts-0.2.xml"],
+  ["iso-13849-1MB",
+   "#{sts_root}/spec/fixtures/ISO_13849-1_2008-12_en_TBX.xml"],
+  ["din-iso-1.1MB",
+   "#{sts_root}/spec/fixtures/DIN_EN_ISO_13849-1_2008-12_en_TBX.xml"],
+]
+
+results = {}
+sts_files.each do |label, path|
+  unless File.exist?(path)
+    puts "  SKIP #{label}: #{path} not found"
+    next
+  end
+  xml = File.read(path)
+  size_kb = File.size(path) / 1024.0
+  results[label] = measure("STS #{label} (#{size_kb.round(0)}KB)") do
+    Sts::NisoSts::Standard.from_xml(xml)
+  end
+end
+
+puts "\n  Gate checks:"
+if results["iso-13849-1MB"]
+  status = results["iso-13849-1MB"][:avg_time] < 2.0 ? "PASS" : "FAIL"
+  printf "  ISO-13849-1MB < 2.0s: %s (%.3fs)\n", status,
+         results["iso-13849-1MB"][:avg_time]
+end
+
+write_results_json(json_output_path, results) if json_output_path

data/bench/bench_unitsml.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Benchmark: Unitsml Ruby (UnitsML parsing)
+# Gate: 1000 parse operations < 2.0s total
+#
+# Usage:
+#   UNITSML_DIR=/path/to/unitsml-ruby ITERATIONS=5 bundle exec ruby tmp/bench/bench_unitsml.rb
+#   BENCH_JSON=/tmp/results.json bundle exec ruby tmp/bench/bench_unitsml.rb
+
+require_relative "bench_common"
+include BenchCommon
+
+print_header("Unitsml Ruby Benchmark — UnitsML expression parsing")
+
+unitsml_root = ENV["UNITSML_DIR"] || "/Users/mulgogi/src/unitsml/unitsml-ruby"
+$LOAD_PATH.unshift("#{unitsml_root}/lib")
+require "unitsml"
+
+# Unitsml parses string expressions like "unitsml(mm*s^-2)"
+expressions = [
+  "unitsml(mm*s^-2)",
+  "unitsml(um)",
+  "unitsml(degK)",
+  "unitsml(prime)",
+  "unitsml(kg*m^2*s^-2)",
+  "unitsml(m*s^-1)",
+  "unitsml(A)",
+  "unitsml(m^2)",
+]
+
+puts "  Parsing #{expressions.size} expressions x 100 times..."
+results = {}
+results["800-expressions"] = measure("Unitsml 800 expressions") do
+  100.times do
+    expressions.each { |exp| Unitsml::Parser.new(exp).parse }
+  end
+end
+
+puts "\n  Note: Unitsml uses parslet for parsing, not heavy lutaml-model XML deserialization."
+puts "  Performance gains here will come from Unitsml::Unit.from_xml and symbol rendering."
+
+write_results_json(json_output_path, results) if json_output_path