xlsxrb 0.1.0

data/Rakefile

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "etc"
+require "fileutils"
+require "open3"
+require "tmpdir"
+
+desc "Build the Open XML SDK runner"
+task :build_sdk_runner do
+  sh "dotnet build vendor/sdk_runner/sdk_runner.csproj -c Release"
+end
+
+def reader_fixture_dir
+  File.expand_path("test/fixtures/reader_generated", __dir__)
+end
+
+def sdk_scenario_dir
+  File.expand_path("test/fixtures/sdk_scenarios", __dir__)
+end
+
+def sdk_runner_dll
+  File.expand_path("vendor/sdk_runner/bin/Release/net8.0/sdk_runner.dll", __dir__)
+end
+
+def reader_fixture_specs
+  Dir.glob(File.join(sdk_scenario_dir, "reader_*_generated_by_sdk.cs")).map do |scenario_path|
+    scenario_name = File.basename(scenario_path, ".cs")
+    [scenario_name, File.join(reader_fixture_dir, "#{scenario_name}.xlsx")]
+  end
+end
+
+def reader_fixture_workers
+  Integer(ENV.fetch("READER_FIXTURE_WORKERS", Etc.nprocessors))
+rescue ArgumentError
+  Etc.nprocessors
+end
+
+desc "Ensure SDK-generated reader fixtures exist"
+task ensure_reader_fixtures: :build_sdk_runner do
+  missing_specs = reader_fixture_specs.reject { |_scenario_name, fixture_path| File.exist?(fixture_path) }
+  next if missing_specs.empty?
+
+  FileUtils.mkdir_p(reader_fixture_dir)
+
+  queue = Queue.new
+  missing_specs.each { |spec| queue << spec }
+  failures = Queue.new
+
+  worker_count = [reader_fixture_workers, missing_specs.size].min
+  threads = Array.new(worker_count) do
+    Thread.new do
+      loop do
+        scenario_name, fixture_path = queue.pop(true)
+        scenario_path = File.join(sdk_scenario_dir, "#{scenario_name}.cs")
+        FileUtils.touch(fixture_path)
+
+        stdout, stderr, status = Open3.capture3(
+          "dotnet", sdk_runner_dll, scenario_path, fixture_path
+        )
+
+        next if status.success?
+
+        FileUtils.rm_f(fixture_path)
+        message = stderr.to_s.strip.empty? ? stdout : stderr
+        failures << "Failed to generate reader fixture #{scenario_name}: #{message}"
+      rescue ThreadError
+        break
+      end
+    end
+  end
+
+  threads.each(&:join)
+  next if failures.empty?
+
+  raise failures.pop
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  workers = ENV.fetch("TEST_WORKERS", Etc.nprocessors)
+  t.options = "--parallel --n-workers=#{workers}"
+end
+
+task test: %i[build_sdk_runner ensure_reader_fixtures]
+
+namespace :test do
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/xlsxrb/**/*_test.rb", "test/*_test.rb"]
+    workers = ENV.fetch("TEST_WORKERS", Etc.nprocessors)
+    t.options = "--parallel --n-workers=#{workers}"
+  end
+
+  Rake::TestTask.new(:contract) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/contract/**/*_test.rb"]
+    workers = ENV.fetch("TEST_WORKERS", Etc.nprocessors)
+    t.options = "--parallel --n-workers=#{workers}"
+  end
+
+  Rake::TestTask.new(:e2e) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/e2e/**/*_test.rb"]
+    workers = ENV.fetch("TEST_WORKERS", Etc.nprocessors)
+    t.options = "--parallel --n-workers=#{workers}"
+  end
+
+  Rake::TestTask.new(:visual) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/visual/**/*_test.rb"]
+    workers = ENV.fetch("TEST_WORKERS", Etc.nprocessors)
+    t.options = "--parallel --n-workers=#{workers}"
+  end
+
+  namespace :fixtures do
+    namespace :reader do
+      desc "Generate reader fixture XLSX files from SDK scenarios"
+      task generate: :ensure_reader_fixtures
+
+      desc "Remove generated reader fixture XLSX files"
+      task :clean do
+        FileUtils.rm_rf(reader_fixture_dir)
+      end
+    end
+  end
+end
+
+task "test:e2e" => %i[build_sdk_runner ensure_reader_fixtures]
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]
+
+namespace :visual do
+  desc "Generate docs/visual/ README.md explanation gallery"
+  task :gallery do
+    require_relative "test/visual/support/gallery_generator"
+    Xlsxrb::Visual::GalleryGenerator.generate
+  end
+
+  desc "Generate / update VRT baselines in test/visual/baselines/"
+  task :baseline do
+    require_relative "test/visual/support/renderer"
+    require "securerandom"
+    examples = Dir.glob(File.expand_path("examples/visual/*.rb", __dir__))
+    baselines_dir = File.expand_path("test/visual/baselines", __dir__)
+
+    FileUtils.rm_rf(baselines_dir)
+    FileUtils.mkdir_p(baselines_dir)
+
+    examples.each do |example_path|
+      name = File.basename(example_path, ".rb")
+      puts "Generating baseline for #{name}..."
+
+      example_tmp_dir = File.join(Dir.tmpdir, "xlsxrb_baselines_build_#{name}_#{SecureRandom.hex(4)}")
+      FileUtils.mkdir_p(example_tmp_dir)
+
+      xlsx_path = File.join(example_tmp_dir, "#{name}.xlsx")
+      system("ruby", "-Ilib", example_path, xlsx_path)
+
+      dest_dir = File.join(baselines_dir, name)
+      begin
+        Xlsxrb::Visual::Renderer.render(xlsx_path, dest_dir)
+      ensure
+        FileUtils.rm_rf(example_tmp_dir)
+      end
+    end
+    puts "Baselines generated successfully."
+  end
+end
+
+desc "Build custom packed ruby.wasm from staging bundle"
+task :wasm do
+  original_wasm_cache = File.expand_path("tmp/test_env/ruby.wasm", __dir__)
+  packed_wasm_path = File.expand_path("docs/wasm/ruby.wasm", __dir__)
+  wasm_bundle_dir = File.expand_path("tmp/wasm_bundle", __dir__)
+
+  # 1. Download original base Wasm if not cached locally
+  unless File.exist?(original_wasm_cache)
+    puts "Downloading original ruby.wasm for caching..."
+    require "open-uri"
+    wasm_url = "https://cdn.jsdelivr.net/npm/@ruby/4.0-wasm-wasi@2.9.3-2.9.4/dist/ruby.wasm"
+    FileUtils.mkdir_p(File.dirname(original_wasm_cache))
+    URI.open(wasm_url) do |stream|
+      File.open(original_wasm_cache, "wb") do |file|
+        IO.copy_stream(stream, file)
+      end
+    end
+    puts "Original ruby.wasm cached successfully."
+  end
+
+  # 2. Synchronize latest lib/xlsxrb.rb to staging bundle directory before packing
+  FileUtils.mkdir_p(File.dirname(packed_wasm_path))
+  FileUtils.cp(File.expand_path("lib/xlsxrb.rb", __dir__), File.join(wasm_bundle_dir, "xlsxrb.rb"))
+
+  # 3. Compile custom ruby.wasm packaging staging libs
+  puts "Building packed ruby.wasm from staging bundle..."
+  cmd = "bundle exec rbwasm pack #{original_wasm_cache} --dir #{wasm_bundle_dir}::/usr/local/lib/ruby/site_ruby -o #{packed_wasm_path}"
+  puts "Executing: #{cmd}"
+  unless system(cmd)
+    raise "Failed to build packed ruby.wasm using rbwasm pack!"
+  end
+end
+
+desc "Generate RDoc documentation including Visual Gallery"
+task doc: :wasm do
+  FileUtils.rm_rf("doc")
+  sh "bundle exec rdoc --title 'xlsxrb Documentation' --main README.md README.md \"docs/visual/VisualGallery.md\" lib/"
+
+  # Copy visual gallery images and files so they are available in RDoc output
+  FileUtils.mkdir_p("doc/test/visual/baselines")
+  FileUtils.cp_r("test/visual/baselines", "doc/test/visual")
+  FileUtils.mkdir_p("doc/test/visual/support/illustrations")
+  FileUtils.cp_r(Dir.glob("test/visual/support/illustrations/*.png"), "doc/test/visual/support/illustrations")
+
+  FileUtils.mkdir_p("doc/docs/visual/files")
+  FileUtils.cp_r(Dir.glob("docs/visual/files/*"), "doc/docs/visual/files")
+
+  # --- WebAssembly Playground Integration ---
+  puts "Integrating WebAssembly Playground..."
+
+  # Copy playground helper assets and custom Wasm binary to doc directory
+  FileUtils.mkdir_p("doc/css")
+  FileUtils.mkdir_p("doc/js")
+  FileUtils.mkdir_p("doc/wasm")
+  FileUtils.cp("docs/wasm/wasm_doc_helper.js", "doc/js/wasm_doc_helper.js")
+  FileUtils.cp("docs/wasm/wasm_doc_helper.css", "doc/css/wasm_doc_helper.css")
+  FileUtils.cp("docs/wasm/ruby.wasm", "doc/wasm/ruby.wasm")
+
+  # Inject stylesheet and javascript loading tags to all generated HTML docs
+  Dir.glob("doc/**/*.html").each do |html_path|
+    html_content = File.read(html_path)
+    depth = html_path.sub(%r{\Adoc/}, "").count("/")
+    rel_prefix = "../" * depth
+
+    js_tag = %Q{<script src="#{rel_prefix}js/wasm_doc_helper.js" defer></script>}
+    css_tag = %Q{<link href="#{rel_prefix}css/wasm_doc_helper.css" rel="stylesheet">}
+
+    if html_content.include?("<body")
+      modified = html_content.sub("<body", "#{js_tag}\n#{css_tag}\n<body")
+      File.write(html_path, modified)
+    end
+  end
+  puts "WebAssembly Playground integrated successfully!"
+  puts "RDoc documentation generated successfully at doc/"
+end
+
+namespace :doc do
+  desc "Build and preview RDoc documentation locally"
+  task preview: :doc do
+    require "webrick"
+    
+    port = ENV.fetch("PORT", "8000").to_i
+    
+    # Configure WEBrick to serve 'doc' directory
+    server = WEBrick::HTTPServer.new(
+      Port: port,
+      DocumentRoot: File.expand_path("doc", __dir__),
+      Logger: WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+      AccessLog: []
+    )
+
+    puts "=================================================="
+    puts " Starting local documentation server at:"
+    puts " http://localhost:#{port}/"
+    puts " Press Ctrl+C to stop the server"
+    puts "=================================================="
+
+    trap("INT") { server.shutdown }
+
+    begin
+      server.start
+    rescue Errno::EADDRINUSE
+      warn "\n[Error] Port #{port} is already in use by another process."
+      warn "Please stop the other process or specify a different port."
+      warn "Example: PORT=8080 bundle exec rake doc:preview\n\n"
+      exit 1
+    end
+  end
+end

data/benchmark.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+ENV["GEM_HOME"] = File.expand_path("tmp/vendor/bundle", __dir__)
+ENV["GEM_PATH"] = ENV.fetch("GEM_HOME", nil)
+
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "benchmark", "0.5.0"
+  gem "rexml", "3.4.4"
+  gem "zlib", "3.2.3"
+  gem "xlsxtream", "3.1.0"
+  gem "caxlsx", "4.4.2"
+  gem "rubyXL", "3.4.35"
+  gem "fast_excel", "0.5.0"
+  gem "roo", "3.0.0"
+  gem "creek", "2.6.3"
+  gem "csv", "3.3.2"
+  gem "xsv", "1.4.0"
+  gem "base64", "0.2.0"
+  gem "opentelemetry-sdk", "1.11.0"
+end
+
+require "json"
+require "benchmark"
+require "fileutils"
+require "objspace"
+require_relative "lib/xlsxrb"
+
+args = ARGV.dup
+KEEP_FILES = args.delete("--keep-files")
+
+ROWS = (args[0] || 10_000).to_i
+COLS = 10
+ITERATIONS = 5
+READ_TEST_FILE = "tmp/benchmark_read_test.xlsx"
+
+OUTPUT_FILES = {
+  "xlsxrb (Streaming)" => "tmp/write_xlsxrb_stream.xlsx",
+  "xlsxrb (In-Memory)" => "tmp/write_xlsxrb_mem.xlsx",
+  "caxlsx (In-Memory)" => "tmp/write_caxlsx.xlsx",
+  "xlsxtream (Streaming)" => "tmp/write_xlsxtream.xlsx",
+  "fast_excel (Streaming)" => "tmp/write_fast_excel.xlsx",
+  "rubyXL (In-Memory)" => "tmp/write_rubyXL.xlsx",
+  "Read source file" => READ_TEST_FILE
+}.freeze
+
+puts "Target: #{ROWS} rows x #{COLS} columns (#{ROWS * COLS} cells)"
+puts "Iterations: #{ITERATIONS}"
+puts "Keep generated files: #{KEEP_FILES ? "yes" : "no"}"
+puts "Preparing test file for read benchmarks..."
+
+# Prepare test file for read benchmarks
+Xlsxrb.generate(READ_TEST_FILE) do |w|
+  w.add_sheet("Test") do |s|
+    ROWS.times do |r|
+      row_data = Array.new(COLS) { |c| (r * COLS) + c }
+      s.add_row(row_data)
+    end
+  end
+end
+
+def run_in_subprocess(_name, &block)
+  File.write("tmp/bench_task.rb", <<~RUBY)
+    ENV['BUNDLE_GEMFILE'] = ''
+    ENV['BUNDLE_IGNORE_CONFIG'] = '1'
+    ENV['GEM_HOME'] = File.expand_path('tmp/vendor/bundle', __dir__)
+    ENV['GEM_PATH'] = ENV['GEM_HOME']
+
+    require 'bundler/inline'
+    gemfile do
+      source 'https://rubygems.org'
+      gem 'benchmark', '0.5.0'
+      gem 'rexml', '3.4.4'
+      gem 'zlib', '3.2.3'
+      gem 'xlsxtream', '3.1.0'
+      gem 'caxlsx', '4.4.2'
+      gem 'rubyXL', '3.4.35'
+      gem 'fast_excel', '0.5.0'
+      gem 'roo', '3.0.0'
+      gem 'creek', '2.6.3'
+      gem 'csv', '3.3.2'
+      gem 'xsv', '1.4.0'
+      gem 'base64', '0.2.0'
+      gem 'opentelemetry-sdk', '1.11.0'
+    end
+    require 'csv'
+    require 'base64'
+    require 'json'
+    require 'benchmark'
+    require 'opentelemetry/sdk'
+    require_relative '../lib/xlsxrb'
+
+    ROWS = #{ROWS}
+    COLS = 10
+    READ_TEST_FILE = "tmp/benchmark_read_test.xlsx"
+
+    def get_io_stats
+      return { rchar: 0, wchar: 0, read_bytes: 0, write_bytes: 0 } unless File.exist?('/proc/self/io')
+
+      stats = {}
+      File.readlines('/proc/self/io').each do |line|
+        key, value = line.split(':')
+        stats[key.strip.to_sym] = value.to_i if key && value
+      end
+      stats
+    end
+
+    class BenchmarkSpanProcessor < OpenTelemetry::SDK::Trace::SpanProcessor
+      def on_start(span, _parent_context)
+        return unless span.name == 'benchmark_task'
+    #{"    "}
+        span.set_attribute('bench.gc.count.start', GC.stat[:count])
+        span.set_attribute('bench.alloc.objects.start', GC.stat[:total_allocated_objects])
+        span.set_attribute('bench.time.start', Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        span.set_attribute('bench.cpu.utime.start', Process.times.utime)
+        span.set_attribute('bench.cpu.stime.start', Process.times.stime)
+        @io_start = get_io_stats
+    #{"    "}
+        @max_mem_mb = 0.0
+        @watcher = Thread.new do
+          loop do
+            mem = `ps -o rss= -p \#{Process.pid}`.to_f / 1024.0
+            @max_mem_mb = mem if mem > @max_mem_mb
+            sleep 0.05
+          end
+        end
+      end
+
+      def on_finish(span)
+        return unless span.name == 'benchmark_task'
+    #{"    "}
+        @watcher.kill
+        mem = `ps -o rss= -p \#{Process.pid}`.to_f / 1024.0
+        @max_mem_mb = mem if mem > @max_mem_mb
+
+        gc_start = span.attributes['bench.gc.count.start']
+        alloc_start = span.attributes['bench.alloc.objects.start']
+        time_start = span.attributes['bench.time.start']
+        utime_start = span.attributes['bench.cpu.utime.start']
+        stime_start = span.attributes['bench.cpu.stime.start']
+        io_end = get_io_stats
+    #{"    "}
+        gc_diff = GC.stat[:count] - gc_start
+        alloc_diff = GC.stat[:total_allocated_objects] - alloc_start
+
+        written_bytes = io_end[:wchar] - @io_start[:wchar]
+        read_bytes = io_end[:rchar] - @io_start[:rchar]
+
+        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end_times = Process.times
+
+        elapsed = end_time - time_start
+        cpu_time = (end_times.utime - utime_start) + (end_times.stime - stime_start)
+        cpu_percent = elapsed > 0 ? (cpu_time / elapsed) * 100 : 0.0
+
+        puts JSON.dump({
+          time: elapsed,
+          cpu: cpu_percent,
+          memory: @max_mem_mb,
+          gc_count: gc_diff,
+          alloc_objects: alloc_diff,
+          rchar: read_bytes,
+          wchar: written_bytes
+        })
+      end
+    end
+
+    OpenTelemetry::SDK.configure do |c|
+      c.add_span_processor(BenchmarkSpanProcessor.new)
+    end
+
+    tracer = OpenTelemetry.tracer_provider.tracer('benchmark')
+    GC.start
+
+    tracer.in_span('benchmark_task') do
+      # --- TASK START ---
+      #{block.call}
+      # --- TASK END ---
+    end
+  RUBY
+
+  output = Bundler.with_unbundled_env do
+    `ruby tmp/bench_task.rb 2>/dev/null`
+  end
+  begin
+    JSON.parse(output, symbolize_names: true)
+  rescue StandardError => e
+    puts "Error: #{e.message} with output: #{output.inspect}"
+    nil
+  end
+end
+
+def run_benchmark(name, snippet)
+  print format("%-25s", name)
+  results = ITERATIONS.times.map do
+    print "."
+    run_in_subprocess(name) { snippet }
+  end
+  puts
+
+  avg_time = results.compact.map { |r| r[:time] }.compact.sum / results.compact.size.to_f
+  avg_cpu = results.compact.map { |r| r[:cpu] }.compact.sum / results.compact.size.to_f
+  avg_mem = results.compact.map { |r| r[:memory] }.compact.sum / results.compact.size.to_f
+  avg_gc = results.compact.map { |r| r[:gc_count] }.compact.sum / results.compact.size.to_f
+  avg_alloc = results.compact.map { |r| r[:alloc_objects] }.compact.sum / results.compact.size.to_f
+  avg_wchar = results.compact.map { |r| r[:wchar] }.compact.sum / results.compact.size.to_f
+  avg_rchar = results.compact.map { |r| r[:rchar] }.compact.sum / results.compact.size.to_f
+
+  {
+    name: name,
+    time: avg_time,
+    cpu: avg_cpu,
+    memory: avg_mem,
+    gc_count: avg_gc,
+    alloc_m: avg_alloc / 1_000_000.0,
+    wchar_mb: avg_wchar / 1_048_576.0,
+    rchar_mb: avg_rchar / 1_048_576.0
+  }
+end
+
+def format_row(result)
+  format("| %-25<name>s | %8.2<time>f s | %9.1<memory>f MB | %8.1<gc_count>f |", result)
+end
+
+puts "\n--- Write Benchmarks ---"
+write_results = []
+
+write_results << run_benchmark("xlsxrb (Streaming)", <<~RUBY
+  Xlsxrb.generate("tmp/write_xlsxrb_stream.xlsx") do |writer|
+    writer.add_sheet("Sheet1") do |sheet|
+      ROWS.times do |r|
+        row_data = Array.new(COLS) { |c| r * COLS + c }
+        sheet.add_row(row_data)
+      end
+    end
+  end
+RUBY
+)
+
+write_results << run_benchmark("xlsxrb (In-Memory)", <<~RUBY
+  workbook = Xlsxrb.build do |w|
+    w.add_sheet("Sheet1") do |sheet|
+      ROWS.times do |r|
+        row_data = Array.new(COLS) { |c| r * COLS + c }
+        sheet.add_row(row_data)
+      end
+    end
+  end
+  Xlsxrb.write("tmp/write_xlsxrb_mem.xlsx", workbook)
+RUBY
+)
+
+write_results << run_benchmark("caxlsx (In-Memory)", <<~RUBY
+  begin
+    p = Axlsx::Package.new
+    sheet = p.workbook.add_worksheet(name: "Sheet1")
+    ROWS.times do |r|
+      sheet.add_row(Array.new(COLS) { |c| r * COLS + c })
+    end
+    p.serialize("tmp/write_caxlsx.xlsx")
+  rescue Zlib::BufError => e
+    File.write("tmp/write_caxlsx.xlsx", "")
+  end
+RUBY
+)
+
+write_results << run_benchmark("xlsxtream (Streaming)", <<~RUBY
+  begin
+    Xlsxtream::Workbook.open("tmp/write_xlsxtream.xlsx") do |workbook|
+      workbook.write_worksheet("Sheet1") do |sheet|
+        ROWS.times do |r|
+          sheet << Array.new(COLS) { |c| r * COLS + c }
+        end
+      end
+    end
+  rescue Zlib::BufError => e
+    File.write("tmp/write_xlsxtream.xlsx", "")
+  end
+RUBY
+)
+
+write_results << run_benchmark("fast_excel (Streaming)", <<~RUBY
+  File.delete("tmp/write_fast_excel.xlsx") if File.exist?("tmp/write_fast_excel.xlsx")
+  workbook = FastExcel.open("tmp/write_fast_excel.xlsx", constant_memory: true)
+  sheet = workbook.add_worksheet("Sheet1")
+  ROWS.times do |r|
+    sheet.append_row(Array.new(COLS) { |c| r * COLS + c })
+  end
+  workbook.close
+RUBY
+)
+
+write_results << run_benchmark("rubyXL (In-Memory)", <<~RUBY
+  workbook = RubyXL::Workbook.new
+  sheet = workbook.worksheets[0]
+  ROWS.times do |r|
+    COLS.times do |c|
+      sheet.add_cell(r, c, r * COLS + c)
+    end
+  end
+  workbook.write("tmp/write_rubyXL.xlsx")
+RUBY
+)
+
+puts "\n--- Read Benchmarks ---"
+read_results = []
+
+read_results << run_benchmark("xlsxrb (Streaming)", <<~RUBY
+  count = 0
+  Xlsxrb.foreach(READ_TEST_FILE) do |row|
+    count += row.cells.size
+  end
+RUBY
+)
+
+read_results << run_benchmark("xlsxrb (In-Memory)", <<~RUBY
+  workbook = Xlsxrb.read(READ_TEST_FILE)
+  count = 0
+  workbook.sheets[0].rows.each do |row|
+    count += row.cells.size
+  end
+RUBY
+)
+
+read_results << run_benchmark("creek (Streaming)", <<~RUBY
+  creek = Creek::Book.new(READ_TEST_FILE)
+  sheet = creek.sheets[0]
+  count = 0
+  sheet.simple_rows.each do |row|
+    count += row.size
+  end
+RUBY
+)
+
+read_results << run_benchmark("roo (Streaming)", <<~RUBY
+  xlsx = Roo::Excelx.new(READ_TEST_FILE)
+  count = 0
+  xlsx.each_row_streaming do |row|
+    count += row.size
+  end
+RUBY
+)
+
+read_results << run_benchmark("rubyXL (In-Memory)", <<~RUBY
+  workbook = RubyXL::Parser.parse(READ_TEST_FILE)
+  count = 0
+  workbook.worksheets[0].each do |row|
+    count += row.cells.size if row
+  end
+RUBY
+)
+
+read_results << run_benchmark("xsv (Streaming)", <<~RUBY
+  workbook = Xsv.open(READ_TEST_FILE)
+  count = 0
+  workbook[0].each do |row|
+    count += row.size
+  end
+RUBY
+)
+
+# Print markdown tables
+puts "\n\n### Write Performance (#{ROWS * COLS} cells)"
+puts "| Library                   | Time       | Peak Memory  | GC Count |"
+puts "|---------------------------|------------|--------------|----------|"
+write_results.sort_by { |r| r[:time] }.each { |r| puts format_row(r) }
+
+puts "\n### Read Performance (#{ROWS * COLS} cells)"
+puts "| Library                   | Time       | Peak Memory  | GC Count |"
+puts "|---------------------------|------------|--------------|----------|"
+read_results.sort_by { |r| r[:time] }.each { |r| puts format_row(r) }
+
+puts "\n### Generated Files"
+puts "| Producer                  | File path                     | Status   |"
+puts "|---------------------------|-------------------------------|----------|"
+OUTPUT_FILES.each do |name, path|
+  status = File.exist?(path) ? "exists" : "missing"
+  puts format("| %-25<name>s | %-29<path>s | %-8<status>s |", name: name, path: path, status: status)
+end
+
+# Cleanup
+if KEEP_FILES
+  puts "\nKeeping generated files because --keep-files was specified."
+else
+  Dir.glob("tmp/write_*.xlsx").each { |f| FileUtils.rm(f) }
+  FileUtils.rm(READ_TEST_FILE)
+end
+FileUtils.rm_f("tmp/bench_task.rb")