expressir 2.2.1 → 2.3.1

data/Gemfile

@@ -2,10 +2,13 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in reeper.gemspec
 gemspec
 
+# Use released parsanol for native extension
+gem "parsanol", "~> 1.3.5"
+
 gem "canon"
+gem "irb"
 gem "lutaml-model", github: "lutaml/lutaml-model", branch: "main"
 gem "openssl", "~> 3.0"
 gem "rake"

data/README.adoc

@@ -117,35 +117,42 @@ Expressir uses the link:https://github.com/parsanol/parsanol-ruby[Parsanol] gem
 
 [cols="3,2,2,3"]
 |===
-| Mode | Time | Speedup | Notes
+| Mode | Time (179K lines) | Speedup | Notes
 
-| Ruby (Parsanol) | 3036 ms | 1x (baseline) | Pure Ruby parsing
-| Native Batch (Parsanol) | 153 ms | 19.9x faster | AST via u64 array transfer
-| Native ZeroCopy (Parsanol) | 106 ms | 28.7x faster | Zero-copy with source positions
+| Ruby (Parslet) | 507 s | 1x (baseline) | Pure Ruby parsing
+| Native (Parsanol) | 29 s | 17x faster | Rust parser with AST transformation
 |===
 
 === Features
 
 When Parsanol is installed:
 
-* **18-44x faster parsing** - Rust native backend
-* **99.5% fewer allocations** - Arena-based AST construction
-* **Source position tracking** - Slice objects for error reporting
-* **Streaming Builder API** - Zero-allocation custom parsing
+* **17x faster parsing** - Rust native backend
+* **Lazy line/column** - Zero overhead for position info
+* **Batch FFI** - Efficient u64 array transfer across language boundary
 
 === Usage
 
-Expressir automatically uses Parsanol when available:
+Expressir automatically uses Parsanol (Rust parser) when available for better performance:
 
 [source,ruby]
 ----
-# Automatically uses Parsanol native parser when available
-repo = Expressir::Express::Parser.from_file("geometry.exp")
+# Parse a single file - returns ExpFile
+exp_file = Expressir::Express::Parser.from_file("geometry.exp")
+schema = exp_file.schemas.first
+puts "Schema: #{schema.id}"
 
 # Check if native parser is being used
 if Parsanol::Native.available?
   puts "Using Parsanol (Rust parser)"
 end
+
+# Parse multiple files - returns Repository
+files = ["schema1.exp", "schema2.exp"]
+repo = Expressir::Express::Parser.from_files(files)
+repo.schemas.each do |s|
+  puts "Schema: #{s.id}"
+end
 ----
 
 For maximum performance, ensure the Parsanol gem is installed:
@@ -240,9 +247,15 @@ https://www.express-language-foundation.org/pretty-print-spec/[ELF Pretty Print
 [source,ruby]
 ----
 # Basic usage - formats with default settings
-repository = Expressir::Express::Parser.from_file("schema.exp")
+# Parser.from_file returns an ExpFile
+exp_file = Expressir::Express::Parser.from_file("schema.exp")
 formatter = Expressir::Express::PrettyFormatter.new
-formatted = formatter.format(repository)
+formatted = formatter.format(exp_file)
+puts formatted
+
+# The formatter also accepts Repository objects
+repo = Expressir::Express::Parser.from_files(["schema1.exp", "schema2.exp"])
+formatted = formatter.format(repo)
 puts formatted
 ----
 
@@ -1319,15 +1332,19 @@ The library provides two main methods for parsing EXPRESS files.
 
 ==== Parsing a single file
 
-Use the `from_file` method to parse a single EXPRESS schema file:
+Use the `from_file` method to parse a single EXPRESS schema file.
+This returns an `ExpFile` object containing the parsed schemas:
 
 [source,ruby]
 ----
-# Parse a single file
-repository = Expressir::Express::Parser.from_file("path/to/schema.exp")
+# Parse a single file - returns ExpFile
+exp_file = Expressir::Express::Parser.from_file("path/to/schema.exp")
+
+# Access schemas from the file
+schema = exp_file.schemas.first
 
 # With options
-repository = Expressir::Express::Parser.from_file(
+exp_file = Expressir::Express::Parser.from_file(
   "path/to/schema.exp",
   skip_references: false,  # Set to true to skip resolving references
   include_source: true,    # Set to true to include original source in the model
@@ -1342,7 +1359,7 @@ error:
 [source,ruby]
 ----
 begin
-  repository = Expressir::Express::Parser.from_file("path/to/schema.exp")
+  exp_file = Expressir::Express::Parser.from_file("path/to/schema.exp")
 rescue Expressir::Express::Error::SchemaParseFailure => e
   puts "Failed to parse schema: #{e.message}"
   puts "Filename: #{e.filename}"
@@ -1352,13 +1369,19 @@ end
 
 ==== Parsing multiple files
 
-Use the `from_files` method to parse multiple EXPRESS schema files:
+Use the `from_files` method to parse multiple EXPRESS schema files.
+This returns a `Repository` object containing all parsed files:
 
 [source,ruby]
 ----
-# Parse multiple files
+# Parse multiple files - returns Repository
 files = ["schema1.exp", "schema2.exp", "schema3.exp"]
 repository = Expressir::Express::Parser.from_files(files)
+
+# Access all schemas across all files
+repository.schemas.each do |schema|
+  puts "Schema: #{schema.id}"
+end
 ----
 
 You can provide a block to track loading progress and handle errors:
@@ -1407,7 +1430,12 @@ Example:
 
 [source,ruby]
 ----
-repo = Expressir::Express::Parser.from_file("path/to/file.exp")
+# Single file (ExpFile)
+exp_file = Expressir::Express::Parser.from_file("path/to/file.exp")
+file_drop = exp_file.to_liquid
+
+# Multiple files (Repository)
+repo = Expressir::Express::Parser.from_files(["file1.exp", "file2.exp"])
 repo_drop = repo.to_liquid
 ----
 
@@ -1438,10 +1466,15 @@ and `Expressir::Liquid::Declarations::SchemaDrop` has same attribute `file`.
 
 [source,ruby]
 ----
-repo = Expressir::Express::Parser.from_file("path/to/file.exp")
-repo_drop = repo.to_liquid
-schema = repo_drop.schemas.first
+# Parse file (returns ExpFile)
+exp_file = Expressir::Express::Parser.from_file("path/to/file.exp")
+file_drop = exp_file.to_liquid
+schema = file_drop.schemas.first
 schema.file = "path/to/file.exp"
+
+# Or parse multiple files (returns Repository)
+repo = Expressir::Express::Parser.from_files(["file1.exp", "file2.exp"])
+repo_drop = repo.to_liquid
 ----
 
 === Documentation coverage analysis
@@ -1454,9 +1487,13 @@ analyze and report on documentation coverage of EXPRESS schemas.
 # Create a coverage report from a file
 report = Expressir::Coverage::Report.from_file("path/to/schema.exp")
 
+# Or create a report from an ExpFile
+exp_file = Expressir::Express::Parser.from_file("path/to/schema.exp")
+report = Expressir::Coverage::Report.from_exp_file(exp_file)
+
 # Or create a report from a repository
-repository = Expressir::Express::Parser.from_file("path/to/schema.exp")
-report = Expressir::Coverage::Report.from_repository(repository)
+repo = Expressir::Express::Parser.from_files(["schema1.exp", "schema2.exp"])
+report = Expressir::Coverage::Report.from_repository(repo)
 
 # Access overall statistics
 puts "Overall coverage: #{report.coverage_percentage}%"

data/benchmark/srl_benchmark.rb

@@ -0,0 +1,399 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# SRL Benchmark Script for Expressir
+# Compares Parsanol Ruby vs Native performance on full STEPmod Resource Library
+# Features: Live progress, emojis, colors, per-schema stats
+
+require "bundler/setup"
+require "benchmark"
+require "fileutils"
+
+# Force loading of native extension
+require "parsanol"
+require "parsanol/native"
+
+# Now require expressir
+require "expressir"
+
+# Configuration
+SRL_PATH = "/Users/mulgogi/src/mn/iso-10303/schemas/resources"
+ITERATIONS = (ENV["ITERATIONS"] || 1).to_i
+TIMEOUT_SECONDS = (ENV["TIMEOUT"] || 30).to_i # Timeout per file
+
+# Check if we're running in an interactive terminal
+INTERACTIVE = $stdout.tty?
+
+# ANSI Color codes
+module Colors
+  RESET = "\e[0m"
+  BOLD = "\e[1m"
+  DIM = "\e[2m"
+
+  # Foreground colors
+  BLACK = "\e[30m"
+  RED = "\e[31m"
+  GREEN = "\e[32m"
+  YELLOW = "\e[33m"
+  BLUE = "\e[34m"
+  MAGENTA = "\e[35m"
+  CYAN = "\e[36m"
+  WHITE = "\e[37m"
+
+  # Bright foreground colors
+  BRIGHT_RED = "\e[91m"
+  BRIGHT_GREEN = "\e[92m"
+  BRIGHT_YELLOW = "\e[93m"
+  BRIGHT_BLUE = "\e[94m"
+  BRIGHT_MAGENTA = "\e[95m"
+  BRIGHT_CYAN = "\e[96m"
+  BRIGHT_WHITE = "\e[97m"
+
+  # Background colors
+  BG_RED = "\e[41m"
+  BG_GREEN = "\e[42m"
+  BG_YELLOW = "\e[43m"
+  BG_BLUE = "\e[44m"
+  BG_MAGENTA = "\e[45m"
+  BG_CYAN = "\e[46m"
+end
+
+include Colors
+
+# Terminal utilities
+module Terminal
+  class << self
+    def width
+      IO.console.winsize[1]
+    rescue StandardError
+      80
+    end
+
+    def clear_line
+      INTERACTIVE ? "\r\e[K" : ""
+    end
+
+    def move_to_start
+      INTERACTIVE ? "\r" : ""
+    end
+  end
+end
+
+# Progress bar
+class ProgressBar
+  def initialize(total, width = 30)
+    @total = total
+    @width = width
+    @current = 0
+  end
+
+  def render(current, label = "")
+    @current = current
+    percentage = (@current.to_f / @total * 100).round(1)
+    filled = (@width * @current / @total.to_f).round
+    empty = @width - filled
+
+    bar = "#{BRIGHT_CYAN}#{'█' * filled}#{DIM}#{'░' * empty}#{RESET}"
+    "#{bar} #{BRIGHT_WHITE}#{percentage.to_s.rjust(5)}%#{RESET} #{DIM}#{label}#{RESET}"
+  end
+end
+
+def find_exp_files
+  Dir.glob("#{SRL_PATH}/*/*.exp").reject do |f|
+    f.include?("quantities_and_units")
+  end
+end
+
+def count_lines(files)
+  files.sum { |f| File.read(f).lines.count }
+end
+
+def format_time(seconds)
+  if seconds < 60
+    "#{seconds.round(2)}s"
+  else
+    minutes = (seconds / 60).floor
+    secs = (seconds % 60).round(1)
+    "#{minutes}m #{secs}s"
+  end
+end
+
+def format_number(num)
+  num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+end
+
+def print_header
+  puts
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts "#{BRIGHT_MAGENTA}║#{RESET}#{BOLD}#{BRIGHT_WHITE}  🚀 EXPRESSIR SRL BENCHMARK 🚀  #{RESET}#{BRIGHT_MAGENTA}║#{RESET}"
+  puts "#{BRIGHT_MAGENTA}║#{RESET}#{DIM}  Ruby vs Native Parser Showdown   #{RESET}#{BRIGHT_MAGENTA}║#{RESET}"
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts
+end
+
+def print_config(files, total_lines)
+  puts "#{BRIGHT_CYAN}⚙️  Configuration#{RESET}"
+  puts "#{DIM}┌─────────────────────────────────────────────┐#{RESET}"
+  puts "#{DIM}│#{RESET} 📁 Files:      #{BRIGHT_WHITE}#{format_number(files.size).rjust(10)}#{RESET}               #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET} 📊 Lines:      #{BRIGHT_WHITE}#{format_number(total_lines).rjust(10)}#{RESET}               #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET} 🔄 Iterations: #{BRIGHT_WHITE}#{ITERATIONS.to_s.rjust(10)}#{RESET}               #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET} 🦀 Native:     #{BRIGHT_WHITE}#{Parsanol::Native.available?.to_s.upcase.rjust(10)}#{RESET}               #{DIM}│#{RESET}"
+  puts "#{DIM}└─────────────────────────────────────────────┘#{RESET}"
+  puts
+end
+
+def print_warmup_start
+  print "#{BRIGHT_YELLOW}🔥 Warming up...#{RESET} "
+end
+
+def print_warmup_done
+  puts "#{BRIGHT_GREEN}✅ Done!#{RESET}"
+  puts
+end
+
+class ParserBenchmark
+  attr_reader :name, :emoji, :color, :results
+
+  def initialize(name:, emoji:, color:, use_native:)
+    @name = name
+    @emoji = emoji
+    @color = color
+    @use_native = use_native
+    @results = []
+  end
+
+  def run(files, _total_lines)
+    puts "#{@color}#{@emoji} #{@name}#{@RESET}"
+    puts "#{DIM}┌──────────────────────────────────────────────────────────┐#{RESET}"
+
+    progress_bar = ProgressBar.new(files.size, 25)
+    iteration_results = { success: 0, failed: 0, errors: [], time: 0,
+                          schema_times: [] }
+    start_time = Time.now
+
+    files.each_with_index do |file, idx|
+      schema_name = File.basename(file, ".exp")
+      file_start = Time.now
+      schema_lines = File.read(file).lines.count
+
+      begin
+        require "timeout"
+        Timeout.timeout(TIMEOUT_SECONDS) do
+          if @use_native
+            content = File.read(file)
+            Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                                         use_native: true)
+          else
+            Expressir::Express::Parser.from_file(file, skip_references: true)
+          end
+        end
+        iteration_results[:success] += 1
+        status = "#{BRIGHT_GREEN}✓#{RESET}"
+      rescue Timeout::Error
+        iteration_results[:failed] += 1
+        iteration_results[:errors] << { file: File.basename(file),
+                                        error: "Timeout after #{TIMEOUT_SECONDS}s" }
+        status = "#{BRIGHT_YELLOW}⏱#{RESET}"
+      rescue StandardError => e
+        iteration_results[:failed] += 1
+        iteration_results[:errors] << { file: File.basename(file),
+                                        error: e.message[0..60] }
+        status = "#{BRIGHT_RED}✗#{RESET}"
+      end
+
+      elapsed = Time.now - file_start
+      iteration_results[:schema_times] << { name: schema_name, time: elapsed,
+                                            lines: schema_lines }
+
+      # Live progress update
+      if INTERACTIVE
+        progress_label = "#{status} #{schema_name[0..20].ljust(21)}"
+        print "#{Terminal.clear_line}  #{progress_bar.render(idx + 1,
+                                                             progress_label)}"
+        $stdout.flush
+      elsif ((idx + 1) % 10).zero? || idx.zero?
+        # Print progress every 10 files when not interactive
+        pct = ((idx + 1).to_f / files.size * 100).round(1)
+        puts "  #{progress_bar.render(idx + 1, "#{pct}% complete")}"
+        $stdout.flush
+      end
+    end
+
+    if INTERACTIVE
+      puts
+    end
+
+    iteration_results[:time] = Time.now - start_time
+    @results << iteration_results
+    iteration_results
+  end
+
+  def print_summary(files, total_lines, result)
+    avg_time = result[:time]
+    lines_per_sec = (total_lines / avg_time).round(1)
+    files_per_sec = (files.size / avg_time).round(2)
+
+    puts "#{DIM}├──────────────────────────────────────────────────────────┤#{RESET}"
+    puts "#{DIM}│#{RESET} #{BOLD}Results:#{RESET}"
+    puts "#{DIM}│#{RESET}   #{BRIGHT_GREEN}✅ Success:#{RESET}  #{BRIGHT_WHITE}#{result[:success].to_s.rjust(5)}#{RESET} / #{files.size} files"
+    puts "#{DIM}│#{RESET}   #{BRIGHT_RED}❌ Failed:#{RESET}   #{BRIGHT_WHITE}#{result[:failed].to_s.rjust(5)}#{RESET} files"
+    puts "#{DIM}│#{RESET}   #{BRIGHT_CYAN}⏱️  Time:#{RESET}    #{BRIGHT_WHITE}#{format_time(avg_time).rjust(5)}#{RESET}"
+    puts "#{DIM}│#{RESET}   #{BRIGHT_YELLOW}⚡ Speed:#{RESET}   #{BRIGHT_WHITE}#{format_number(lines_per_sec).rjust(5)}#{RESET} lines/sec"
+
+    if result[:failed].positive? && result[:failed] <= 5
+      puts "#{DIM}├──────────────────────────────────────────────────────────┤#{RESET}"
+      puts "#{DIM}│#{RESET} #{BRIGHT_RED}⚠️  Errors:#{RESET}"
+      result[:errors].first(3).each do |err|
+        puts "#{DIM}│#{RESET}    #{DIM}• #{err[:file]}: #{err[:error][0..40]}#{RESET}"
+      end
+    end
+
+    puts "#{DIM}└──────────────────────────────────────────────────────────┘#{RESET}"
+    puts
+
+    { avg_time: avg_time, lines_per_sec: lines_per_sec,
+      files_per_sec: files_per_sec }
+  end
+
+  def print_slowest_schemas(result, count = 5)
+    return if result[:schema_times].empty?
+
+    slowest = result[:schema_times].sort_by { |s| -s[:time] }.first(count)
+
+    puts "#{@color}#{@emoji} Slowest Schemas#{@RESET}"
+    puts "#{DIM}┌─────────────────────────────────────────────────────┐#{RESET}"
+    slowest.each_with_index do |s, i|
+      rank = "#{BRIGHT_WHITE}#{(i + 1).to_s.rjust(2)}.#{RESET}"
+      name = s[:name][0..25].ljust(26)
+      time = "#{BRIGHT_CYAN}#{s[:time].round(1)}s#{RESET}".rjust(8)
+      lines = "#{DIM}#{s[:lines]} lines#{RESET}"
+      puts "#{DIM}│#{RESET} #{rank} #{name} #{time} #{lines}"
+    end
+    puts "#{DIM}└─────────────────────────────────────────────────────┘#{RESET}"
+    puts
+  end
+end
+
+def print_comparison(ruby_stats, native_stats, files, total_lines)
+  speedup = (ruby_stats[:avg_time] / native_stats[:avg_time]).round(1)
+  time_saved = (ruby_stats[:avg_time] - native_stats[:avg_time]).round(2)
+
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts "#{BOLD}#{BRIGHT_WHITE}       📊 PERFORMANCE COMPARISON 📊       #{RESET}"
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts
+
+  puts "#{DIM}┌─────────────────────────────────────────────────────┐#{RESET}"
+  puts "#{DIM}│#{RESET}#{BOLD}                 HEAD-TO-HEAD                   #{RESET}#{DIM}│#{RESET}"
+  puts "#{DIM}├─────────────────────────────────────────────────────┤#{RESET}"
+  puts "#{DIM}│#{RESET}                                                     #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}  #{BRIGHT_BLUE}💎 Ruby Parser#{RESET}    #{format_time(ruby_stats[:avg_time]).rjust(10)}               #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}     #{DIM}#{format_number(ruby_stats[:lines_per_sec])} lines/sec#{RESET}                          #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}                                                     #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}  #{BRIGHT_CYAN}🦀 Native Parser#{RESET}   #{format_time(native_stats[:avg_time]).rjust(10)}               #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}     #{DIM}#{format_number(native_stats[:lines_per_sec])} lines/sec#{RESET}                          #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}                                                     #{DIM}│#{RESET}"
+  puts "#{DIM}├─────────────────────────────────────────────────────┤#{RESET}"
+
+  if speedup > 1
+    puts "#{DIM}│#{RESET}  #{BOLD}#{BRIGHT_GREEN}🏆 WINNER: Native Parser#{RESET}                     #{DIM}│#{RESET}"
+    puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⚡ Speedup:#{RESET}     #{BOLD}#{BRIGHT_GREEN}#{speedup}x FASTER#{RESET}                  #{DIM}│#{RESET}"
+    puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⏱️  Time Saved:#{RESET}  #{BRIGHT_GREEN}#{format_time(time_saved)} per run#{RESET}             #{DIM}│#{RESET}"
+  else
+    puts "#{DIM}│#{RESET}  #{BOLD}#{BRIGHT_BLUE}🏆 WINNER: Ruby Parser#{RESET}                       #{DIM}│#{RESET}"
+    puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⚡ Speedup:#{RESET}     #{BOLD}#{BRIGHT_BLUE}#{(1 / speedup).round(1)}x FASTER#{RESET}                  #{DIM}│#{RESET}"
+  end
+
+  puts "#{DIM}│#{RESET}                                                     #{DIM}│#{RESET}"
+  puts "#{DIM}└─────────────────────────────────────────────────────┘#{RESET}"
+  puts
+
+  # Summary
+  puts "#{DIM}┌─────────────────────────────────────────────────────┐#{RESET}"
+  puts "#{DIM}│#{RESET}#{BOLD}                    SUMMARY                        #{RESET}#{DIM}│#{RESET}"
+  puts "#{DIM}├─────────────────────────────────────────────────────┤#{RESET}"
+  puts "#{DIM}│#{RESET}  📦 #{format_number(files.size)} schemas (#{format_number(total_lines)} lines)         #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}  #{BRIGHT_BLUE}Ruby:#{RESET}   #{format_time(ruby_stats[:avg_time]).rjust(8)}                              #{DIM}│#{RESET}"
+  puts "#{DIM}│#{RESET}  #{BRIGHT_CYAN}Native:#{RESET} #{format_time(native_stats[:avg_time]).rjust(8)}                              #{DIM}│#{RESET}"
+  puts "#{DIM}└─────────────────────────────────────────────────────┘#{RESET}"
+  puts
+end
+
+def print_footer
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts "#{BOLD}#{BRIGHT_WHITE}         ✨ BENCHMARK COMPLETE ✨          #{RESET}"
+  puts "#{BRIGHT_MAGENTA}#{'═' * 60}#{RESET}"
+  puts
+end
+
+# ==================== MAIN ====================
+
+print_header
+
+# Find all EXPRESS files
+files = find_exp_files
+total_lines = count_lines(files)
+
+if files.empty?
+  puts "#{BRIGHT_RED}❌ ERROR: No EXPRESS files found at #{SRL_PATH}#{RESET}"
+  exit 1
+end
+
+print_config(files, total_lines)
+
+# Warmup
+print_warmup_start
+warmup_file = files.first
+
+begin
+  Expressir::Express::Parser.from_file(warmup_file, skip_references: true)
+rescue StandardError => e
+  puts "#{BRIGHT_YELLOW}⚠️  Ruby warmup warning: #{e.message[0..40]}#{RESET}"
+end
+
+if Parsanol::Native.available?
+  begin
+    content = File.read(warmup_file)
+    Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                                 use_native: true)
+  rescue StandardError => e
+    puts "#{BRIGHT_YELLOW}⚠️  Native warmup warning: #{e.message[0..40]}#{RESET}"
+  end
+end
+
+print_warmup_done
+
+# Ruby Benchmark
+ruby_benchmark = ParserBenchmark.new(
+  name: "Ruby Parser",
+  emoji: "💎",
+  color: BRIGHT_BLUE,
+  use_native: false,
+)
+
+ruby_result = ruby_benchmark.run(files, total_lines)
+ruby_stats = ruby_benchmark.print_summary(files, total_lines, ruby_result)
+ruby_benchmark.print_slowest_schemas(ruby_result)
+
+# Native Benchmark (if available)
+if Parsanol::Native.available?
+  native_benchmark = ParserBenchmark.new(
+    name: "Native Parser (Rust)",
+    emoji: "🦀",
+    color: BRIGHT_CYAN,
+    use_native: true,
+  )
+
+  native_result = native_benchmark.run(files, total_lines)
+  native_stats = native_benchmark.print_summary(files, total_lines,
+                                                native_result)
+  native_benchmark.print_slowest_schemas(native_result)
+
+  # Print comparison
+  print_comparison(ruby_stats, native_stats, files, total_lines)
+else
+  puts "#{BRIGHT_YELLOW}⚠️  Native parser not available. Run `rake compile` in parsanol-ruby to build.#{RESET}"
+  puts
+end
+
+print_footer