xmi 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef7e586a3a637179d25efce69e62366184380659e0aa757a5c57327e8c190aa
-  data.tar.gz: c8331b279ba8c54c8333dc4c954a2812558a35f844811c641ed49922fbe11492
+  metadata.gz: 1ac4f03d86ac8abffeaecaf956bcd77ab9a3bb2ed6348a12f3ccb2bd587f2eec
+  data.tar.gz: 7f0051b7bbb867c4c7d82ad95fb435a4f5e5d9bb2b76e1297ded8953682489c1
 SHA512:
-  metadata.gz: 36141b75f57006f831f6c9e1081f73a737a08e79bd281f295de59a39ff495ef91fa0437899842158d49688b0b08f8b8a5801ade3c6a17f0dbbbce93b1cf4d07d
-  data.tar.gz: 5bbd57fbae92032dbf081532f905974bf89f1faafa1c07a49d40d794050972a1d11ffeaff8b361fe3256f662a6e30a9ec855b14a372a9ef77ecf037d2817fd33
+  metadata.gz: 99a98d34c015c29e2170695e0e3918a98ec9a4308097a32886bd0af401808172b367c2e2da020713dc0ff2db5581c9336b4a4a64e3d3b39b225f4df5cde0296d
+  data.tar.gz: 060447e7ae2275a40e4881616dc104032c491ae4cc3bb0707bcfbcafb7bf93a068ff6cda7da3cbeb62c37c3ef5d8e34f66a1dfd1a11206b509e99d3af27a7d8e

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-03-22 01:00:16 UTC using RuboCop version 1.85.1.
+# on 2026-04-14 03:59:00 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,78 +11,68 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'xmi.gemspec'
 
-# Offense count: 8
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
-# SupportedStylesAlignWith: start_of_line, relative_to_receiver
-Layout/IndentationWidth:
-  Exclude:
-    - 'scripts-xmi-profile/profile_xmi_simple.rb'
-
-# Offense count: 67
+# Offense count: 72
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: aligned, indented, indented_relative_to_receiver
-Layout/MultilineMethodCallIndentation:
-  Exclude:
-    - 'spec/xmi/sparx/sparx_root_citygml_spec.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowInHeredoc.
-Layout/TrailingWhitespace:
+# Offense count: 5
+# Configuration parameters: AllowedMethods.
+# AllowedMethods: enums
+Lint/ConstantDefinitionInBlock:
   Exclude:
-    - 'scripts-xmi-profile/profile_xmi_simple.rb'
-    - 'spec/xmi/versioning_spec.rb'
+    - 'spec/performance/xmi_parsing_spec.rb'
 
-# Offense count: 2
+# Offense count: 12
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
+    - 'lib/tasks/benchmark_runner.rb'
+    - 'lib/tasks/performance_comparator.rb'
+    - 'lib/tasks/performance_helpers.rb'
     - 'lib/xmi/ea_root.rb'
     - 'lib/xmi/version_registry.rb'
+    - 'spec/performance/xmi_parsing_spec.rb'
 
-# Offense count: 94
+# Offense count: 95
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 143
 
-# Offense count: 12
+# Offense count: 1
+# Configuration parameters: AllowedMethods, AllowedPatterns, Max.
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - 'lib/tasks/performance_helpers.rb'
+
+# Offense count: 26
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 25
+  Max: 33
 
-# Offense count: 1
+# Offense count: 2
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
+    - 'lib/tasks/performance_helpers.rb'
     - 'lib/xmi/version_registry.rb'
 
-# Offense count: 13
+# Offense count: 19
 # Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers, AllowedPatterns.
 # SupportedStyles: snake_case, normalcase, non_integer
 # AllowedIdentifiers: TLS1_1, TLS1_2, capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64
 Naming/VariableNumber:
   Exclude:
+    - 'lib/tasks/benchmark_runner.rb'
     - 'lib/xmi/v20110701.rb'
     - 'lib/xmi/v20131001.rb'
     - 'lib/xmi/v20161101.rb'
+    - 'spec/performance/xmi_parsing_spec.rb'
     - 'spec/xmi/versioning_spec.rb'
 
-# Offense count: 1
-# This cop supports unsafe autocorrection (--autocorrect-all).
-Performance/TimesMap:
-  Exclude:
-    - 'benchmark_parse.rb'
-
 # Offense count: 1
 RSpec/BeforeAfterAll:
   Exclude:
@@ -99,37 +89,26 @@ RSpec/ContextWording:
     - 'spec/xmi/sparx/sparx_root_gml_spec.rb'
     - 'spec/xmi/sparx/sparx_root_mdg_spec.rb'
 
-# Offense count: 3
+# Offense count: 4
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Exclude:
+    - 'spec/performance/xmi_parsing_spec.rb'
     - 'spec/xmi/edge_cases_spec.rb'
     - 'spec/xmi/namespace_aliases_spec.rb'
     - 'spec/xmi/versioning_spec.rb'
 
-# Offense count: 4
-# This cop supports unsafe autocorrection (--autocorrect-all).
-# Configuration parameters: SkipBlocks, EnforcedStyle, OnlyStaticConstants.
-# SupportedStyles: described_class, explicit
-RSpec/DescribedClass:
-  Exclude:
-    - 'spec/xmi/sparx/sparx_root_citygml_spec.rb'
-
 # Offense count: 26
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
-  Max: 31
+  Max: 33
 
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: CustomTransform, IgnoredWords, DisallowedExamples.
-# DisallowedExamples: works
-RSpec/ExampleWording:
+# Offense count: 5
+RSpec/LeakyConstantDeclaration:
   Exclude:
-    - 'spec/xmi/sparx/sparx_root_eauml_spec.rb'
-    - 'spec/xmi/sparx/sparx_root_gml_spec.rb'
+    - 'spec/performance/xmi_parsing_spec.rb'
 
-# Offense count: 35
+# Offense count: 36
 RSpec/MultipleExpectations:
   Max: 8
 
@@ -138,31 +117,15 @@ RSpec/MultipleExpectations:
 RSpec/MultipleMemoizedHelpers:
   Max: 7
 
-# Offense count: 7
+# Offense count: 8
 # Configuration parameters: AllowedGroups.
 RSpec/NestedGroups:
   Max: 4
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: trailing_conditional, ternary
-Style/EmptyStringInsideInterpolation:
-  Exclude:
-    - 'scripts-xmi-profile/profile_xmi_simple.rb'
-
-# Offense count: 5
+# Offense count: 4
 # Configuration parameters: AllowedClasses.
 Style/OneClassPerFile:
   Exclude:
+    - 'lib/tasks/benchmark_runner.rb'
     - 'lib/xmi.rb'
     - 'lib/xmi/namespace/dynamic.rb'
-    - 'spec/xmi/sparx/shared_contexts.rb'
-
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, diff_comma, no_comma
-Style/TrailingCommaInArguments:
-  Exclude:
-    - 'spec/xmi/sparx/sparx_root_citygml_spec.rb'

data/Gemfile

@@ -5,6 +5,8 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in xmi.gemspec
 gemspec
 
+gem "benchmark"
+gem "benchmark-ips"
 gem "canon"
 gem "lutaml-model", github: "lutaml/lutaml-model", ref: "main"
 gem "rake"

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/lib/tasks/benchmark_runner.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+# Ensure lib/ is on the load path regardless of tmp location
+lib_path = File.expand_path(File.join(__dir__, "..", "..", "lib"))
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require "xmi"
+
+# Pretty terminal formatting for benchmark output
+module Term
+  CLEAR   = "\e[0m"
+  BOLD    = "\e[1m"
+  DIM     = "\e[2m"
+  RED     = "\e[31m"
+  GREEN   = "\e[32m"
+  YELLOW  = "\e[33m"
+  CYAN    = "\e[36m"
+  MAGENTA = "\e[35m"
+
+  HL = "─"
+  VL = "│"
+  TL = "┌"
+  TR = "┐"
+  BL = "└"
+  BR = "┘"
+
+  def self.header(title, color: CYAN)
+    width = 78
+    line = HL * width
+    puts
+    puts "#{color}#{TL}#{line}#{TR}#{CLEAR}"
+    puts "#{color}#{VL}#{CLEAR}  #{BOLD}#{color}#{title}#{CLEAR}#{' ' * (width - title.length - 4)}#{color}#{VL}#{CLEAR}"
+    puts "#{color}#{BL}#{line}#{BR}#{CLEAR}"
+  end
+
+  def self.sep(char: HL, width: 78)
+    puts "#{DIM}#{char * width}#{CLEAR}"
+  end
+
+  def self.env_info(ruby_version, platform)
+    puts
+    puts "  #{DIM}Environment:#{CLEAR}"
+    puts "  #{VL}  Ruby #{ruby_version} on #{platform}#{' ' * (60 - ruby_version.length - platform.length)}#{VL}"
+    puts "  #{DIM}#{BL}#{HL * 76}#{BR}#{CLEAR}"
+    puts
+  end
+
+  def self.category(title, icon:, description:, failure_means:,
+compare_against: nil)
+    puts
+    puts "#{CYAN}#{VL}#{CLEAR}  #{BOLD}#{MAGENTA}#{icon} #{title}#{CLEAR}"
+    puts
+    puts "  #{DIM}#{description}#{CLEAR}"
+    puts
+
+    if compare_against
+      puts "  #{CYAN}Comparing against:#{CLEAR} #{compare_against}"
+      puts
+    end
+
+    puts "  #{YELLOW}⚠️  Failure means:#{CLEAR} #{failure_means}"
+    puts
+    sep(width: 76)
+    puts
+  end
+end
+
+class BenchmarkRunner
+  REPO_ROOT = File.expand_path(File.join(__dir__, "..", ".."))
+
+  # Benchmark configuration
+  DEFAULT_RUN_TIME = 5
+  DEFAULT_WARMUP = 2
+
+  # Category definitions with descriptions
+  CATEGORIES = {
+    xmi_parsing: {
+      name: "XMI Parsing",
+      icon: "📄",
+      description: "XMI parsing performance tests. Measures how quickly we can convert XMI files into Ruby objects.",
+      failure_means: "Slow XMI parsing impacts all downstream operations. A regression here means users will experience delays when processing XMI documents.",
+      compare_against: "Previous branch (main).",
+    },
+  }.freeze
+
+  # Test definitions
+  BENCHMARKS = {
+    xmi_parsing: [
+      { name: "XMI 2.4.2 (small)", method: :xmi_parse_242_small,
+        desc: "XMI 2.4.2 ~100KB file" },
+      { name: "XMI 2.4.2 (medium)", method: :xmi_parse_242_medium,
+        desc: "XMI 2.4.2 ~500KB file with extensions" },
+      { name: "XMI 2.4.2 (large)", method: :xmi_parse_242_large,
+        desc: "XMI 2.4.2 ~3.5MB file" },
+      { name: "XMI 2.5.1", method: :xmi_parse_251,
+        desc: "XMI 2.5.1 ~100KB file" },
+    ],
+  }.freeze
+
+  # Test data - fixture paths
+  FIXTURES = {
+    xmi_parse_242_small: "spec/fixtures/xmi-v2-4-2-default.xmi",
+    xmi_parse_242_medium: "spec/fixtures/xmi-v2-4-2-default-with-citygml.xmi",
+    xmi_parse_242_large: "spec/fixtures/full-242.xmi",
+    xmi_parse_251: "spec/fixtures/ea-xmi-2.5.1.xmi",
+  }.freeze
+
+  def initialize(run_time: nil, warmup: nil, benchmark: nil)
+    @run_time = run_time || DEFAULT_RUN_TIME
+    @warmup = warmup || DEFAULT_WARMUP
+    @benchmark = benchmark
+    @results = {}
+    @env_shown = false
+    @all_results = []
+  end
+
+  def run_benchmarks
+    Term.header("XMI Performance Benchmarks", color: Term::CYAN)
+
+    unless @env_shown
+      Term.env_info(RUBY_VERSION, RUBY_PLATFORM)
+      @env_shown = true
+    end
+
+    BENCHMARKS.each do |category, tests|
+      run_category(category, tests)
+    end
+
+    print_summary
+
+    @results
+  end
+
+  private
+
+  def run_category(category, tests)
+    config = CATEGORIES[category]
+    Term.category(
+      config[:name],
+      icon: config[:icon],
+      description: config[:description],
+      failure_means: config[:failure_means],
+      compare_against: config[:compare_against],
+    )
+
+    category_results = []
+
+    tests.each do |test|
+      # Redirect stdout during benchmark
+      original_stdout = $stdout
+      $stdout = StringIO.new
+
+      result = run_single_test(test[:method])
+      (result[:lower] + result[:upper]) / 2.0
+      category_results << { name: test[:name], result: result }
+
+      # Restore stdout
+      $stdout = original_stdout
+    end
+
+    # Print results
+    puts "  #{'Benchmark'.ljust(40)} #{'IPS'.rjust(12)} #{'Deviation'.rjust(12)}"
+    puts "  #{Term::DIM}#{Term::HL * 66}#{Term::CLEAR}"
+
+    category_results.each do |r|
+      ips = (r[:result][:lower] + r[:result][:upper]) / 2.0
+      deviation = calculate_deviation(r[:result])
+      label = "#{config[:name]}: #{r[:name]}"
+      @all_results << { label: label, ips: ips }
+      @results[label] = r[:result]
+
+      puts "  #{r[:name].ljust(40)} #{format('%.2f',
+                                             ips).rjust(12)} #{format('%.1f%%',
+                                                                      deviation).rjust(12)}"
+    end
+
+    puts
+  end
+
+  def run_single_test(method)
+    fixture_path = FIXTURES[method]
+    raise "Unknown fixture: #{method}" unless fixture_path
+
+    # Try to resolve fixture path relative to REPO_ROOT
+    full_path = File.join(REPO_ROOT, fixture_path)
+    unless File.exist?(full_path)
+      # Fallback: try current directory
+      full_path = fixture_path
+    end
+
+    xml_content = File.read(full_path)
+
+    case method
+    when :xmi_parse_242_small, :xmi_parse_242_medium, :xmi_parse_242_large, :xmi_parse_251
+      measure_time { Xmi::Sparx::SparxRoot.parse_xml(xml_content) }
+    else
+      raise "Unknown benchmark: #{method}"
+    end
+  end
+
+  def measure(&)
+    job = Benchmark::IPS::Job.new
+    job.config(time: @run_time, warmup: @warmup)
+    job.report("test", &)
+    job.run
+
+    entry = job.full_report.entries.first
+    samples = entry.stats.samples
+
+    return { lower: 0, upper: 0 } if samples.empty?
+
+    mean = samples.sum.to_f / samples.size
+    variance = samples.sum { |x| (x - mean)**2 } / (samples.size - 1)
+    std_dev = Math.sqrt(variance)
+    error_margin = std_dev / mean
+    error_pct = error_margin.round(4)
+
+    { lower: mean.round(4) * (1 - error_pct),
+      upper: mean.round(4) * (1 + error_pct) }
+  end
+
+  def measure_time
+    times = []
+    iterations = 5
+
+    iterations.times do
+      start_t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+      finish_t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      times << (finish_t - start_t)
+    end
+
+    mean = times.sum / times.size
+    variance = times.sum { |t| (t - mean)**2 } / (times.size - 1)
+    std_dev = Math.sqrt(variance)
+
+    # Use conservative estimates for time-based measurement
+    lower_time = [mean - std_dev, mean * 0.5].max
+    lower_ips = (1.0 / (lower_time * 1.5)).round(4)
+    upper_ips = (1.0 / mean).round(4)
+
+    # For fast operations, estimate more conservatively
+    if mean < 0.001
+      upper_ips = (1.0 / mean).round(4)
+      lower_ips = (upper_ips * 0.8).round(4)
+    end
+
+    { lower: lower_ips, upper: upper_ips }
+  end
+
+  def calculate_deviation(metrics)
+    return 0 if metrics[:upper].zero?
+
+    ((metrics[:upper] - metrics[:lower]) / metrics[:upper] * 100).round(1)
+  end
+
+  def print_summary
+    puts
+    Term.sep(width: 78)
+    puts
+    puts "  #{Term::BOLD}#{Term::MAGENTA}SUMMARY#{Term::CLEAR}"
+    puts
+
+    @all_results.each do |r|
+      puts "  #{r[:label].ljust(60)} #{format('%.2f', r[:ips]).rjust(10)} IPS"
+    end
+
+    puts
+    puts "  #{Term::DIM}#{@all_results.length} benchmarks completed#{Term::CLEAR}"
+    puts
+  end
+end

data/lib/tasks/performance.rake

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "performance_comparator"
+require_relative "benchmark_runner"
+
+desc "Run performance benchmarks"
+namespace :performance do
+  desc "Compare performance of current branch against base branch (default: main)"
+  task :compare do
+    PerformanceComparator.new.run
+  end
+
+  desc "Run benchmarks on current branch only (for development)"
+  task :run do
+    runner = BenchmarkRunner.new(run_time: 5)
+    runner.run_benchmarks
+  end
+
+  desc "Quick benchmark run (faster, less accurate)"
+  task :quick do
+    runner = BenchmarkRunner.new(run_time: 2, warmup: 1)
+    runner.run_benchmarks
+  end
+
+  desc "Run benchmarks and output as JSON"
+  task :json do
+    require "json"
+    runner = BenchmarkRunner.new(run_time: 5)
+
+    # Suppress pretty output, just get results
+    results = runner.send(:run_benchmarks)
+
+    output = results.each_with_object({}) do |(label, metrics), h|
+      ips = (metrics[:lower] + metrics[:upper]) / 2.0
+      deviation = ((metrics[:upper] - metrics[:lower]) / metrics[:upper] * 100).round(1)
+      h[label] = {
+        ips: ips.round(2),
+        lower: metrics[:lower].round(2),
+        upper: metrics[:upper].round(2),
+        deviation: deviation,
+      }
+    end
+
+    puts JSON.pretty_generate(output)
+  end
+end

data/lib/tasks/performance_comparator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "performance_helpers"
+
+class PerformanceComparator
+  REPO_ROOT = File.expand_path(File.join(__dir__, "..", ".."))
+  DEFAULT_RUN_TIME = 10
+  DEFAULT_THRESHOLD = 0.10 # 10% (more lenient for complex operations)
+  DEFAULT_BASE = "main"
+  TMP_PERF_DIR = File.join(REPO_ROOT, "tmp", "performance")
+  BENCH_SCRIPT = File.join(TMP_PERF_DIR, "benchmark_runner.rb")
+
+  def run
+    setup_environment
+    run_benchmarks_comparison
+  ensure
+    cleanup
+  end
+
+  private
+
+  def setup_environment
+    Dir.chdir(REPO_ROOT)
+    FileUtils.mkdir_p(TMP_PERF_DIR)
+    FileUtils.cp(File.join(REPO_ROOT, "lib", "tasks", "benchmark_runner.rb"),
+                 BENCH_SCRIPT)
+
+    PerformanceHelpers.load_into_namespace(PerformanceHelpers::Current,
+                                           BENCH_SCRIPT)
+    PerformanceHelpers.clone_base_repo(DEFAULT_BASE, TMP_PERF_DIR, BENCH_SCRIPT)
+  end
+
+  def run_benchmarks_comparison
+    all_current = {}
+    all_base = {}
+
+    puts PerformanceHelpers::Term.header("Performance Comparison", color: PerformanceHelpers::CYAN)
+    puts
+    puts "  #{PerformanceHelpers::DIM}Comparing#{PerformanceHelpers::CLEAR}:"
+    puts "  #{PerformanceHelpers::CYAN}  Current#{PerformanceHelpers::CLEAR}: #{PerformanceHelpers.current_branch}"
+    puts "  #{PerformanceHelpers::CYAN}  Base#{PerformanceHelpers::CLEAR}: #{DEFAULT_BASE}"
+    puts "  #{PerformanceHelpers::CYAN}  Threshold#{PerformanceHelpers::CLEAR}: #{(DEFAULT_THRESHOLD * 100).round(0)}% regression allowed"
+    puts
+
+    # Run all benchmarks
+    base_runner = PerformanceHelpers::Base::BenchmarkRunner.new(
+      run_time: DEFAULT_RUN_TIME,
+    )
+    current_runner = PerformanceHelpers::Current::BenchmarkRunner.new(
+      run_time: DEFAULT_RUN_TIME,
+    )
+
+    PerformanceHelpers.run_benchmarks(
+      base_runner,
+      current_runner,
+      DEFAULT_THRESHOLD,
+      all_base,
+      all_current,
+    )
+
+    summary = PerformanceHelpers.summary_report(
+      all_current,
+      all_base,
+      DEFAULT_BASE,
+      DEFAULT_RUN_TIME,
+      DEFAULT_THRESHOLD,
+    )
+
+    handle_results(summary)
+  end
+
+  def handle_results(summary)
+    puts
+    if summary[:regressions].any?
+      puts "  #{PerformanceHelpers::RED}#{PerformanceHelpers::BOLD}❌ PERFORMANCE REGRESSIONS DETECTED#{PerformanceHelpers::CLEAR}"
+      puts "  #{PerformanceHelpers::RED}#{summary[:regressions].length} benchmark(s) regressed beyond threshold#{PerformanceHelpers::CLEAR}"
+      puts
+      exit(1)
+    else
+      puts "  #{PerformanceHelpers::GREEN}#{PerformanceHelpers::BOLD}✅ ALL BENCHMARKS PASSED#{PerformanceHelpers::CLEAR}"
+      puts
+    end
+  end
+
+  def cleanup
+    FileUtils.rm_rf(TMP_PERF_DIR)
+  end
+end

data/lib/tasks/performance_helpers.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "tmpdir"
+require "fileutils"
+
+module PerformanceHelpers
+  # ANSI color codes for terminal output
+  CLEAR   = "\e[0m"
+  BOLD    = "\e[1m"
+  DIM     = "\e[2m"
+  CYAN    = "\e[36m"
+  GREEN   = "\e[32m"
+  YELLOW  = "\e[33m"
+  RED     = "\e[31m"
+  GRAY    = "\e[90m"
+  MAGENTA = "\e[35m"
+
+  # Terminal formatting helpers
+  module Term
+    extend self
+
+    HL = "─"
+    VL = "│"
+    TL = "┌"
+    TR = "┐"
+    BL = "└"
+    BR = "┘"
+
+    def header(title, color: PerformanceHelpers::CYAN)
+      width = 78
+      line = HL * width
+      puts
+      puts "#{color}#{TL}#{line}#{TR}#{CLEAR}"
+      puts "#{color}#{VL}#{CLEAR}  #{BOLD}#{color}#{title}#{CLEAR}#{' ' * (width - title.length - 4)}#{color}#{VL}#{CLEAR}"
+      puts "#{color}#{BL}#{line}#{BR}#{CLEAR}"
+    end
+
+    def sep(char: HL, width: 78)
+      puts "#{DIM}#{char * width}#{CLEAR}"
+    end
+  end
+
+  module Base
+  end
+
+  module Current
+  end
+
+  class << self
+    def load_into_namespace(module_obj, file_path)
+      content = File.read(file_path)
+      module_obj.module_eval(content, file_path)
+    end
+
+    def ruby_exec(cmd, env: {})
+      Open3.capture3(env, cmd)
+    end
+
+    def current_branch
+      stdout, = ruby_exec("git rev-parse --abbrev-ref HEAD")
+      stdout.strip
+    end
+
+    # Clone base branch into a temp dir and return its path
+    def clone_base_repo(base, performance_dir, script)
+      puts "#{DIM}Cloning base #{base}...#{CLEAR}"
+      safe_ref = base.gsub(/[^0-9A-Za-z._-]/, "-")
+      clone_dir = File.join(performance_dir, "base-#{safe_ref}")
+      FileUtils.rm_rf(clone_dir)
+
+      repo_url, = ruby_exec("git config --get remote.origin.url")
+      repo_url = repo_url.strip
+
+      stdout, stderr, status = ruby_exec("git clone --branch #{safe_ref} --single-branch #{repo_url} #{clone_dir}")
+      raise "git clone failed: #{stderr}\n#{stdout}" unless status.success?
+
+      Dir.chdir(clone_dir) do
+        stdout, stderr, status = ruby_exec("bundle install --quiet")
+        raise "bundle install failed: #{stderr}\n#{stdout}" unless status.success?
+
+        bench_copy_dir = File.join(clone_dir, "lib", "tasks")
+        FileUtils.mkdir_p(bench_copy_dir)
+        bench_copy = File.join(bench_copy_dir, "benchmark_runner.rb")
+        File.write(bench_copy, File.read(script))
+        load_into_namespace(Base, bench_copy)
+      end
+    end
+
+    def run_benchmarks(base_runner, current_runner, threshold, all_base,
+                       all_current)
+      base_results = base_runner.run_benchmarks
+      curr_results = current_runner.run_benchmarks
+
+      all_base.merge!(base_results)
+      all_current.merge!(curr_results)
+
+      # Collect comparison results
+      comparison_rows = []
+
+      curr_results.each do |label, result|
+        base_result = base_results[label]
+        cmp = compare_metrics(label, result, base_result, threshold)
+        comparison_rows << cmp
+      end
+
+      print_comparison_table(comparison_rows, threshold)
+    end
+
+    def print_comparison_table(comparison_rows, threshold)
+      rows = comparison_rows.map do |cmp|
+        {
+          benchmark: cmp[:label],
+          base_ips: cmp[:base_ips]&.round(1),
+          curr_ips: cmp[:curr_ips]&.round(1),
+          change: cmp[:change] ? "#{(cmp[:change] * 100).round(1)}%" : "N/A",
+          status: if cmp[:base_ips].nil?
+                    "NEW"
+                  elsif cmp[:change] < -threshold
+                    "REGRESSED"
+                  else
+                    "OK"
+                  end,
+        }
+      end
+
+      return if rows.empty?
+
+      puts "  #{'Benchmark'.ljust(40)} #{'Base IPS'.rjust(12)} #{'Curr IPS'.rjust(12)} #{'Change'.rjust(10)} #{'Status'.rjust(10)}"
+      puts "  #{DIM}#{'─' * 86}#{CLEAR}"
+
+      rows.each do |row|
+        status_color = case row[:status]
+                       when "REGRESSED" then RED
+                       when "NEW" then YELLOW
+                       else GREEN
+                       end
+        row[:status] == "REGRESSED" ? RED : DIM
+
+        puts "  #{row[:benchmark].ljust(40)} #{format('%-12.1f',
+                                                      row[:base_ips] || 0)} #{format('%-12.1f',
+                                                                                     row[:curr_ips] || 0)} #{format('%-10s', row[:change]).gsub('%',
+                                                                                                                                                '%%')} #{status_color}#{row[:status].rjust(10)}#{CLEAR}"
+      end
+
+      puts
+    end
+
+    def compare_metrics(label, curr, base, threshold)
+      unless base
+        return { label: label, base_ips: nil, curr_ips: nil, change: nil,
+                 regressed: false }
+      end
+
+      base_ips = base.fetch(:lower)
+      curr_ips = curr.fetch(:upper)
+      change = (curr_ips - base_ips) / base_ips.to_f
+
+      {
+        label: label,
+        base_ips: base_ips,
+        curr_ips: curr_ips,
+        change: change,
+        regressed: change < -threshold,
+      }
+    end
+
+    def summary_report(current_results, base_results, base, run_time, threshold)
+      summary = {
+        run_time: run_time,
+        threshold: threshold,
+        branch: current_branch,
+        base: base,
+        regressions: [],
+        new_benchmarks: [],
+      }
+
+      current_results.each do |label, metrics|
+        base_result = base_results[label]
+        cmp = compare_metrics(label, metrics, base_result, threshold)
+
+        # Track new benchmarks that don't exist in base
+        if base_result.nil?
+          summary[:new_benchmarks] << label
+          next
+        end
+
+        next unless cmp[:regressed]
+
+        summary[:regressions] << {
+          label: label,
+          base_ips: cmp[:base_ips],
+          curr_ips: cmp[:curr_ips],
+          delta_fraction: cmp[:change],
+        }
+      end
+
+      log_regressions(summary[:regressions], threshold)
+      log_new_benchmarks(summary[:new_benchmarks])
+      summary
+    end
+
+    def log_new_benchmarks(new_benchmarks)
+      return if new_benchmarks.empty?
+
+      puts
+      puts "#{YELLOW}🆕 New benchmarks (not in base branch):#{CLEAR}"
+      new_benchmarks.each do |label|
+        puts "  • #{label}"
+      end
+    end
+
+    def log_regressions(regressions, threshold)
+      return if regressions.empty?
+
+      puts
+      puts "#{RED}⚠️  Performance Regressions Detected#{CLEAR}"
+      puts "#{RED}   (< -#{(threshold * 100).round(2)}% IPS)#{CLEAR}"
+      puts
+      regressions.each do |regression|
+        delta = regression[:delta_fraction]
+        base_ips = regression[:base_ips]
+        curr_ips = regression[:curr_ips]
+
+        delta_str = delta ? format("%+0.2f%%", delta * 100) : "N/A"
+        base_str = base_ips ? format("%.2f", base_ips) : "N/A"
+        curr_str = curr_ips ? format("%.2f", curr_ips) : "N/A"
+
+        puts "  #{BOLD}#{regression[:label]}#{CLEAR}"
+        puts "    #{GRAY}base: #{base_str} IPS#{CLEAR}"
+        puts "    #{RED}curr: #{curr_str} IPS#{CLEAR}"
+        puts "    #{RED}change: #{delta_str}#{CLEAR}"
+        puts
+      end
+    end
+  end
+end

data/lib/xmi/parsing.rb

@@ -100,7 +100,10 @@ module Xmi
         # Explicit version
         if options[:version]
           reg = VersionRegistry.register_for_version(options[:version])
-          raise ArgumentError, "Unknown version: #{options[:version]}" unless reg
+          unless reg
+            raise ArgumentError,
+                  "Unknown version: #{options[:version]}"
+          end
 
           return reg
         end

data/lib/xmi/sparx/connector.rb

@@ -194,7 +194,7 @@ module Xmi
 
       class Connector < Lutaml::Model::Serializable
         attribute :name, :string
-        attribute :idref, :string
+        attribute :idref, ::Xmi::Type::XmiIdRef
         attribute :source, Source
         attribute :target, Target
         attribute :model, Model

data/lib/xmi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Xmi
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/lib/xmi/version_registry.rb

@@ -95,7 +95,10 @@ module Xmi
         all_versions = [versions[:xmi], versions[:uml], versions[:umldi],
                         versions[:umldc]].compact.uniq
 
-        extend_fallback_for_mixed_namespaces(primary_register, all_versions) if all_versions.length > 1
+        if all_versions.length > 1
+          extend_fallback_for_mixed_namespaces(primary_register,
+                                               all_versions)
+        end
 
         primary_register
       end

data/lib/xmi/versioned.rb

@@ -46,7 +46,8 @@ module Xmi
     #
     # @return [Lutaml::Model::Register]
     def create_register
-      reg = Lutaml::Model::Register.new(register_id, fallback: fallback_registers)
+      reg = Lutaml::Model::Register.new(register_id,
+                                        fallback: fallback_registers)
 
       # Register in GlobalRegister first
       Lutaml::Model::GlobalRegister.register(reg)
@@ -128,7 +129,9 @@ module Xmi
     #
     # @return [Class, nil]
     def uml_namespace
-      namespace_classes.find { |ns| ns.uri.include?("/UML/") && !ns.uri.include?("UMLD") }
+      namespace_classes.find do |ns|
+        ns.uri.include?("/UML/") && !ns.uri.include?("UMLD")
+      end
     end
 
     # @api public

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xmi
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-22 00:00:00.000000000 Z
+date: 2026-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -56,11 +56,14 @@ files:
 - Gemfile
 - README.adoc
 - Rakefile
-- benchmark_parse.rb
 - bin/console
 - bin/setup
 - docs/migration.md
 - docs/versioning.md
+- lib/tasks/benchmark_runner.rb
+- lib/tasks/performance.rake
+- lib/tasks/performance_comparator.rb
+- lib/tasks/performance_helpers.rb
 - lib/xmi.rb
 - lib/xmi/add.rb
 - lib/xmi/custom_profile.rb
@@ -100,7 +103,6 @@ files:
 - lib/xmi/version.rb
 - lib/xmi/version_registry.rb
 - lib/xmi/versioned.rb
-- scripts-xmi-profile/profile_xmi_simple.rb
 - sig/xmi.rbs
 - xmi.gemspec
 homepage: https://github.com/lutaml/xmi

data/benchmark_parse.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-# Benchmark script for XMI parsing performance.
-# Usage: bundle exec ruby benchmark_parse.rb
-#
-# Parses the full-242.xmi fixture (3.5 MB) multiple times and reports
-# average, min, and max parse times.
-
-require "bundler/setup"
-require "xmi"
-
-FIXTURE_PATH = File.join(__dir__, "spec", "fixtures", "full-242.xmi")
-WARMUP_RUNS = 2
-BENCH_RUNS = 5
-
-abort "Fixture not found: #{FIXTURE_PATH}" unless File.exist?(FIXTURE_PATH)
-
-xml_content = File.read(FIXTURE_PATH)
-file_size_mb = File.size(FIXTURE_PATH).to_f / (1024 * 1024)
-
-puts "XMI Parsing Benchmark"
-puts "=" * 50
-puts "File: #{FIXTURE_PATH}"
-puts "Size: #{file_size_mb.round(2)} MB"
-puts "Ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM})"
-puts "Warmup runs: #{WARMUP_RUNS}"
-puts "Benchmark runs: #{BENCH_RUNS}"
-puts
-
-# Warmup
-puts "Warming up..."
-WARMUP_RUNS.times do |i|
-  GC.start
-  Xmi::Sparx::SparxRoot.parse_xml(xml_content)
-  puts "  Warmup #{i + 1}/#{WARMUP_RUNS} complete"
-end
-
-# Benchmark
-puts "Benchmarking..."
-times = BENCH_RUNS.times.map do |i|
-  GC.start
-  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  Xmi::Sparx::SparxRoot.parse_xml(xml_content)
-  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  elapsed = t1 - t0
-  puts "  Run #{i + 1}/#{BENCH_RUNS}: #{elapsed.round(3)}s"
-  elapsed
-end
-
-avg = times.sum / times.size
-min = times.min
-max = times.max
-
-puts
-puts "Results"
-puts "-" * 50
-puts "Average: #{avg.round(3)} s"
-puts "Min:     #{min.round(3)} s"
-puts "Max:     #{max.round(3)} s"
-puts "StdDev:  #{Math.sqrt(times.sum { |t| (t - avg)**2 } / times.size).round(3)} s"

data/scripts-xmi-profile/profile_xmi_simple.rb

@@ -1,213 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Simple XMI Performance Profiling Script (no external dependencies)
-#
-# This script helps identify performance bottlenecks using only Ruby's
-# standard library. Run from the xmi repository.
-#
-# Usage:
-#   XMI_SAMPLE_FILE=path/to/sample.xmi ruby scripts-xmi-profile/profile_xmi_simple.rb
-
-require "bundler/setup"
-require "benchmark"
-require "objspace"
-
-begin
-  require "xmi"
-rescue LoadError
-  puts "ERROR: xmi gem not found. Please run this script from the xmi repository."
-  exit 1
-end
-
-SAMPLE_FILE = ENV.fetch("XMI_SAMPLE_FILE", nil)
-
-unless SAMPLE_FILE && File.exist?(SAMPLE_FILE)
-  puts <<~MSG
-    ERROR: No sample XMI file specified.
-
-    Please set the XMI_SAMPLE_FILE environment variable:
-      XMI_SAMPLE_FILE=path/to/sample.xmi ruby scripts-xmi-profile/profile_xmi_simple.rb
-  MSG
-  exit 1
-end
-
-puts "=" * 80
-puts "XMI Simple Performance Profile"
-puts "=" * 80
-
-xmi_content = File.read(SAMPLE_FILE)
-puts "File: #{SAMPLE_FILE} (#{File.size(SAMPLE_FILE)} bytes)"
-puts
-
-# Method call tracing
-puts "-" * 40
-puts "Method Call Tracing (top 30 by calls)"
-puts "-" * 40
-
-call_counts = Hash.new(0)
-Hash.new(0.0)
-
-trace = TracePoint.new(:call, :c_call) do |tp|
-  # Only trace lutaml-model code
-  next unless tp.path&.include?("lutaml")
-
-  method_name = "#{tp.defined_class}##{tp.method_id}"
-  call_counts[method_name] += 1
-end
-
-# Enable tracing and run
-GC.start
-trace.enable
-start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-begin
-  Xmi::Sparx::SparxRoot.parse_xml(xmi_content)
-rescue StandardError => e
-  puts "Parse error (continuing with profile): #{e.message}"
-end
-
-finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-trace.disable
-
-puts "Total parse time: #{(finish - start).round(3)}s"
-puts
-
-# Sort by call count
-sorted_by_calls = call_counts.sort_by { |_, count| -count }.first(30)
-
-puts "By call count:"
-sorted_by_calls.each do |method, count|
-  # Truncate long method names
-  display_method = method.length > 70 ? "...#{method[-67..]}" : method
-  puts "  #{count.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse.rjust(12)}: #{display_method}"
-end
-puts
-
-# Look for potential issues
-puts "-" * 40
-puts "Potential Issues"
-puts "-" * 40
-
-# Check for methods called excessively
-excessive_threshold = 10_000
-excessive = call_counts.select { |_, count| count > excessive_threshold }
-if excessive.any?
-  puts "Methods called more than #{excessive_threshold} times:"
-  excessive.sort_by { |_, c| -c }.each do |method, count|
-    puts "  #{count.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse}: #{method}"
-  end
-else
-  puts "No methods called more than #{excessive_threshold} times"
-end
-puts
-
-# Check for duplicate detection in mapping
-duplicate_checks = call_counts.select { |m, _| m.include?("eql?") || m.include?("==") }
-if duplicate_checks.any?
-  puts "Duplicate detection calls:"
-  duplicate_checks.sort_by { |_, c| -c }.each do |method, count|
-    puts "  #{count}: #{method}"
-  end
-end
-puts
-
-# Memory analysis
-puts "-" * 40
-puts "Memory Analysis"
-puts "-" * 40
-
-GC.start
-before = ObjectSpace.count_objects
-
-begin
-  Xmi::Sparx::SparxRoot.parse_xml(xmi_content)
-rescue StandardError => e
-  puts "Parse error (continuing): #{e.message}"
-end
-
-GC.start
-after = ObjectSpace.count_objects
-
-puts "Object count changes:"
-%i[T_OBJECT T_ARRAY T_HASH T_STRING T_DATA T_SYMBOL].each do |type|
-  diff = (after[type] || 0) - (before[type] || 0)
-  puts "  #{type}: #{diff >= 0 ? '+' : ''}#{diff}"
-end
-puts
-
-# Transformation registry analysis
-puts "-" * 40
-puts "Transformation Registry Analysis"
-puts "-" * 40
-
-if defined?(Lutaml::Model::TransformationRegistry)
-  registry = Lutaml::Model::TransformationRegistry.instance
-  begin
-    count = begin
-              registry.send(:transformations)&.size
-    rescue StandardError
-              "N/A"
-    end
-    puts "Registered transformations: #{count}"
-  rescue StandardError => e
-    puts "Could not access transformation count: #{e.message}"
-  end
-
-  # Try to get cache stats if available
-  if registry.respond_to?(:cache_stats)
-    puts "Cache stats: #{registry.cache_stats}"
-  end
-end
-puts
-
-# Check for mapping accumulation
-puts "-" * 40
-puts "Mapping Accumulation Check"
-puts "-" * 40
-
-# Look at all loaded classes that include Lutaml::Model::Serialize
-lutaml_classes = ObjectSpace.each_object(Class).select do |klass|
-  
-    klass.include?(Lutaml::Model::Serialize)
-rescue StandardError
-    false
-  
-end
-
-puts "Lutaml::Model classes loaded: #{lutaml_classes.size}"
-
-# Check for classes with many mappings
-classes_with_many_mappings = lutaml_classes.select do |klass|
-  mappings = begin
-               klass.mappings_for(:xml)&.elements
-  rescue StandardError
-               []
-  end
-  mappings.size > 20
-end
-
-if classes_with_many_mappings.any?
-  puts "Classes with >20 mappings:"
-  classes_with_many_mappings.each do |klass|
-    mappings = begin
-                 klass.mappings_for(:xml)&.elements
-    rescue StandardError
-                 []
-    end
-    puts "  #{klass}: #{mappings.size} mappings"
-  end
-else
-  puts "No classes with excessive mappings (>20)"
-end
-puts
-
-# Summary
-puts "=" * 80
-puts "Summary"
-puts "=" * 80
-puts "Total method calls traced: #{call_counts.values.sum}"
-puts "Unique methods called: #{call_counts.size}"
-puts
-puts "To share this profile with the lutaml-model team:"
-puts "  XMI_SAMPLE_FILE=spec/fixtures/full-242.xmi ruby scripts-xmi-profile/profile_xmi_simple.rb > profile_output.txt 2>&1"