xlsxrb 0.1.4 → 0.1.5

data/benchmark.rb

@@ -1,400 +0,0 @@
-# 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 median(array)
-  return 0.0 if array.empty?
-
-  sorted = array.sort
-  len = sorted.length
-  (sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
-end
-
-def run_benchmark(name, snippet)
-  print format("%-25s", name)
-  results = ITERATIONS.times.map do
-    print "."
-    run_in_subprocess(name) { snippet }
-  end
-  puts
-
-  valid_results = results.compact
-
-  median_time = median(valid_results.map { |r| r[:time] }.compact)
-  median_cpu = median(valid_results.map { |r| r[:cpu] }.compact)
-  median_mem = median(valid_results.map { |r| r[:memory] }.compact)
-  median_gc = median(valid_results.map { |r| r[:gc_count] }.compact)
-  median_alloc = median(valid_results.map { |r| r[:alloc_objects] }.compact)
-  median_wchar = median(valid_results.map { |r| r[:wchar] }.compact)
-  median_rchar = median(valid_results.map { |r| r[:rchar] }.compact)
-
-  {
-    name: name,
-    time: median_time,
-    cpu: median_cpu,
-    memory: median_mem,
-    gc_count: median_gc,
-    alloc_m: median_alloc / 1_000_000.0,
-    wchar_mb: median_wchar / 1_048_576.0,
-    rchar_mb: median_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")

data/measure_memory.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "opentelemetry/sdk"
-require "objspace"
-require_relative "lib/xlsxrb"
-
-# Outputs memory and GC stats for a given tracing span
-class MemorySpanProcessor < OpenTelemetry::SDK::Trace::SpanProcessor
-  def on_start(span, _parent_context)
-    span.set_attribute("ruby.gc.count.start", GC.stat[:count])
-    span.set_attribute("ruby.memory.bytes_allocated.start", ObjectSpace.memsize_of_all)
-  end
-
-  def on_finish(span)
-    gc_start = span.attributes["ruby.gc.count.start"]
-    mem_start = span.attributes["ruby.memory.bytes_allocated.start"]
-
-    gc_diff = GC.stat[:count] - (gc_start || 0)
-    mem_diff = ObjectSpace.memsize_of_all - (mem_start || 0)
-
-    mem_mb = mem_diff.to_f / 1024 / 1024
-
-    puts "[#{span.name}] Memory delta: #{mem_mb.round(2)} MB, GC count: #{gc_diff}"
-  end
-end
-
-OpenTelemetry::SDK.configure do |c|
-  c.add_span_processor(MemorySpanProcessor.new)
-end
-
-puts "Generating 100,000 cells (10,000 rows x 10 cols) to measure memory..."
-
-# Using a smaller size first so it runs quickly
-Xlsxrb.generate("test_memory.xlsx") do |w|
-  w.add_sheet("Data") do
-    10_000.times do |i|
-      w.add_row(["A", "B", "C", "D", "E", "F", "G", "H", "I", i])
-    end
-  end
-end
-
-puts "Done."

data/sig/xlsxrb.rbs

@@ -1,23 +0,0 @@
-module Xlsxrb
-  VERSION: String
-
-  module Ooxml
-    class Event
-      attr_reader type: Symbol
-      attr_reader args: Array[untyped]
-      attr_reader source: Hash[Symbol, untyped]
-
-      def self.new: (type: Symbol, args: Array[untyped], source: Hash[Symbol, untyped]) -> Event
-    end
-
-    class WorksheetParser
-      def self.each_event: (String, ?shared_strings: Array[String], ?part_name: String) ?{ (Event) -> void } -> void
-                        | (String, ?shared_strings: Array[String], ?part_name: String) -> Enumerator[Event, void]
-    end
-
-    class SharedStringsParser
-      def self.each_event: (String, ?part_name: String) ?{ (Event) -> void } -> void
-                        | (String, ?part_name: String) -> Enumerator[Event, void]
-    end
-  end
-end