xmi 0.6.1 → 0.7.0

data/lib/tasks/benchmark_runner.rb

@@ -1,274 +0,0 @@
-# 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::Root.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_comparator.rb

@@ -1,88 +0,0 @@
-# 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

@@ -1,238 +0,0 @@
-# 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