serialbench 0.1.2 → 0.2.0

data/docs/WINDOWS_SETUP.md

@@ -0,0 +1,122 @@
+# Windows Setup Guide for Serialbench
+
+This guide explains how to set up serialbench on Windows, particularly for installing the `libxml-ruby` gem which requires native libxml2 libraries.
+
+## Problem
+
+The `libxml-ruby` gem requires native C libraries (libxml2) that need to be installed separately on Windows. Without these libraries, bundler will fail when trying to install the gem.
+
+## Solution
+
+### Option 1: Using Chocolatey (Recommended)
+
+1. Install [Chocolatey](https://chocolatey.org/install) if you haven't already:
+
+```powershell
+Set-ExecutionPolicy Bypass -Scope Process -Force
+[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+```
+
+2. Install libxml2 and required tools:
+
+```powershell
+choco install -y libxml2
+choco install -y pkgconfiglite
+```
+
+3. Set environment variables (you may need to adjust paths based on your installation):
+
+```powershell
+# Find the actual libxml2 installation path
+$libxmlPath = (Get-ChildItem "C:\ProgramData\chocolatey\lib\libxml2" -Recurse -Filter "libxml2.dll" | Select-Object -First 1).Directory.Parent.FullName
+
+# Set PKG_CONFIG_PATH
+$env:PKG_CONFIG_PATH = "$libxmlPath\lib\pkgconfig"
+[System.Environment]::SetEnvironmentVariable('PKG_CONFIG_PATH', $env:PKG_CONFIG_PATH, 'User')
+
+# Add to PATH
+$env:PATH = "$libxmlPath\bin;$env:PATH"
+$currentPath = [System.Environment]::GetEnvironmentVariable('PATH', 'User')
+[System.Environment]::SetEnvironmentVariable('PATH', "$libxmlPath\bin;$currentPath", 'User')
+```
+
+4. Install Ruby dependencies:
+
+```powershell
+bundle install
+```
+
+### Option 2: Using vcpkg
+
+1. Install vcpkg:
+
+```powershell
+git clone https://github.com/Microsoft/vcpkg.git
+cd vcpkg
+.\bootstrap-vcpkg.bat
+.\vcpkg integrate install
+```
+
+2. Install libxml2:
+
+```powershell
+.\vcpkg install libxml2:x64-windows
+```
+
+3. Set environment variables:
+
+```powershell
+$vcpkgPath = "C:\path\to\vcpkg\installed\x64-windows"
+$env:PKG_CONFIG_PATH = "$vcpkgPath\lib\pkgconfig"
+$env:PATH = "$vcpkgPath\bin;$env:PATH"
+```
+
+### Option 3: Skip libxml-ruby (Testing Only)
+
+If you don't need to test the libxml serializer, you can temporarily exclude it:
+
+```ruby
+# In Gemfile or when installing
+bundle install --without libxml
+```
+
+Or remove it from the gemspec temporarily (not recommended for CI).
+
+## Troubleshooting
+
+### Error: "Cannot find libxml2"
+
+This means the libxml2 libraries are not in the expected locations. Try:
+
+1. Verify libxml2 is installed:
+```powershell
+where libxml2.dll
+```
+
+2. Check pkg-config can find it:
+```powershell
+pkg-config --libs libxml-2.0
+```
+
+3. Manually specify the path when installing the gem:
+```powershell
+gem install libxml-ruby -- --with-xml2-dir="C:\path\to\libxml2"
+```
+
+### Error: "mkmf.log shows missing headers"
+
+The development headers aren't found. Make sure you installed the complete libxml2 package including headers.
+
+## GitHub Actions CI
+
+For CI/CD on GitHub Actions, see `.github/workflows/windows-setup.yml` for the complete setup that:
+
+1. Installs libxml2 via Chocolatey
+2. Configures environment paths
+3. Runs bundle install
+4. Executes tests
+
+## Local Development
+
+For local development on Windows, follow the Chocolatey or vcpkg installation steps above. There is no automated Rake task - you must manually install libxml2 before running `bundle install`.

data/lib/serialbench/benchmark_runner.rb

@@ -36,7 +36,7 @@ module Serialbench
         serializers: Serializers.information,
         parsing: run_parsing_benchmarks,
         generation: run_generation_benchmarks,
-        memory_usage: run_memory_benchmarks,
+        memory: run_memory_benchmarks,
         streaming: run_streaming_benchmarks
       )
     end
@@ -221,7 +221,7 @@ module Serialbench
               city: "City #{i % 100}",
               preferences: {
                 theme: i.even? ? 'dark' : 'light',
-                notifications: i % 3 == 0
+                notifications: (i % 3).zero?
               }
             }
           }
@@ -244,7 +244,7 @@ module Serialbench
               data: {
                 field1: "Value #{i}",
                 field2: i * 2,
-                field3: i % 100 == 0 ? 'special' : 'normal',
+                field3: (i % 100).zero? ? 'special' : 'normal',
                 nested: [
                   "Item #{i}-1",
                   "Item #{i}-2",

data/lib/serialbench/cli/benchmark_cli.rb

@@ -242,6 +242,79 @@ module Serialbench
 
       private
 
+      def execute_local_benchmark(environment, config, benchmark_config_path)
+        say '🏠 Executing local benchmark', :green
+
+        runner = Serialbench::BenchmarkRunner.new(
+          environment_config: environment,
+          benchmark_config: config
+        )
+
+        # Run benchmarks
+        results = runner.run_all_benchmarks
+
+        platform = Serialbench::Models::Platform.current_local
+
+        metadata = Models::RunMetadata.new(
+          benchmark_config_path: benchmark_config_path,
+          environment_config_path: "config/environments/#{environment.name}.yml",
+          tags: [
+            'local',
+            platform.os,
+            platform.arch,
+            "ruby-#{environment.ruby_build_tag}"
+          ]
+        )
+
+        # Create results directory
+        result_dir = "results/runs/#{environment.name}-results"
+        FileUtils.mkdir_p(result_dir)
+
+        # Save results to single YAML file with platform and metadata merged in
+        results_model = Models::Result.new(
+          platform: platform,
+          metadata: metadata,
+          environment_config: environment,
+          benchmark_config: config,
+          benchmark_result: results
+        )
+
+        results_file = File.join(result_dir, 'results.yaml')
+        results_model.to_file(results_file)
+
+        say '✅ Local benchmark completed successfully!', :green
+        say "Results saved to: #{result_dir}", :cyan
+        say "Generate site: serialbench benchmark build-site #{result_dir}", :white
+      rescue StandardError => e
+        say "❌ Local benchmark failed: #{e.message}", :red
+        say "Details: #{e.backtrace.first(3).join("\n")}", :white if options[:verbose]
+        raise e
+      end
+
+      def execute_docker_benchmark(environment, config, benchmark_config_path)
+        say '🐳 Executing Docker benchmark', :green
+
+        require_relative '../runners/docker_runner'
+
+        environment_config_path = "config/environments/#{environment.name}.yml"
+        runner = Runners::DockerRunner.new(environment, environment_config_path)
+
+        # Create results directory
+        result_dir = "results/runs/#{environment.name}-results"
+        FileUtils.mkdir_p(result_dir)
+
+        # Run benchmark
+        runner.run_benchmark(config, benchmark_config_path, result_dir)
+
+        say '✅ Docker benchmark completed successfully!', :green
+        say "Results saved to: #{result_dir}", :cyan
+        say "Generate site: serialbench benchmark build-site #{result_dir}", :white
+      rescue StandardError => e
+        say "❌ Docker benchmark failed: #{e.message}", :red
+        say "Details: #{e.backtrace.first(3).join("\n")}", :white if options[:verbose]
+        raise e
+      end
+
       def show_execute_usage_and_exit
         say '❌ Error: Environment and config file arguments are required.', :red
         say ''
@@ -350,7 +423,7 @@ module Serialbench
       #   raise e
       # end
 
-      def execute_asdf_benchmark(environment, config, benchmark_config_path)
+      def execute_asdf_benchmark(environment, _config, benchmark_config_path)
         say '🔧 Executing ASDF benchmark', :green
 
         # Use the ASDF runner to execute the benchmark

data/lib/serialbench/cli/environment_cli.rb

@@ -169,9 +169,9 @@ module Serialbench
         when 'asdf'
           require_relative '../runners/asdf_runner'
           Runners::AsdfRunner.new(environment_config, environment_config_path)
-        # when 'local'
-        #   require_relative '../runners/local_runner'
-        #   Runners::LocalRunner.new(environment_config, environment_config_path)
+        when 'local'
+          require_relative '../runners/local_runner'
+          Runners::LocalRunner.new(environment_config, environment_config_path)
         else
           raise "Unknown environment type: #{environment_config.kind}"
         end

data/lib/serialbench/cli/resultset_cli.rb

@@ -20,7 +20,7 @@ module Serialbench
           serialbench resultset create cross-platform-test results/sets/cross-platform-test
       DESC
       def create(resultset_name, resultset_path)
-        store = Serialbench::Models::ResultStore.default
+        Serialbench::Models::ResultStore.default
 
         # Check if resultset already exists
         definition_path = File.join(resultset_path, 'resultset.yaml')
@@ -49,36 +49,83 @@ module Serialbench
         exit 1
       end
 
-      desc 'add-result RESULT_PATH RESULTSET_PATH', 'Add a run to a resultset'
+      desc 'add-result RESULTSET_PATH RESULT_PATH...', 'Add one or more runs to a resultset'
       long_desc <<~DESC
-        Add an existing benchmark run to a resultset.
+        Add one or more benchmark runs to a resultset.
 
-        RESULT_PATH should be the path to a run result directory
-        RESULTSET_PATH must be specified explicitly
+        RESULTSET_PATH is the path to the resultset directory
+        RESULT_PATH... accepts multiple result paths (supports shell expansion)
 
         Examples:
-          serialbench resultset add-result results/sets/performance-comparison results/runs/my-run-local-macos-arm64-ruby-3.3.8
-          serialbench resultset add-result results/sets/cross-platform-test results/runs/my-docker-run
+          # Add single result
+          serialbench resultset add-result results/sets/weekly results/runs/my-run
+
+          # Add multiple results explicitly
+          serialbench resultset add-result results/sets/weekly results/runs/run1 results/runs/run2
+
+          # Add multiple results with shell expansion
+          serialbench resultset add-result results/sets/weekly artifacts/benchmark-results-*/
+          serialbench resultset add-result results/sets/weekly results/runs/*
       DESC
-      def add_result(resultset_path, result_path)
+      def add_result(resultset_path, *result_paths)
+        if result_paths.empty?
+          say '❌ Error: At least one result path must be provided', :red
+          exit 1
+        end
+
         resultset = Serialbench::Models::ResultSet.load(resultset_path)
 
-        # Validate that the run location exists
-        unless Dir.exist?(result_path)
-          say "Result directory not found: #{result_path}", :red
-          return
+        say "📦 Adding #{result_paths.size} result(s) to resultset", :cyan
+        say "ResultSet: #{resultset_path}", :white
+        say ''
+
+        added_count = 0
+        failed_count = 0
+        skipped_count = 0
+
+        result_paths.each_with_index do |result_path, index|
+          say "#{index + 1}/#{result_paths.size} Processing: #{result_path}", :cyan
+
+          # Find results.yaml in the path or subdirectories
+          results_file = if File.exist?(File.join(result_path, 'results.yaml'))
+                           File.join(result_path, 'results.yaml')
+                         else
+                           Dir.glob(File.join(result_path, '**/results.yaml')).first
+                         end
+
+          unless results_file
+            say '  ⚠️  No results.yaml found - skipping', :yellow
+            skipped_count += 1
+            next
+          end
+
+          result_dir = File.dirname(results_file)
+
+          begin
+            resultset.add_result(result_dir)
+            say '  ✅ Added successfully', :green
+            added_count += 1
+          rescue StandardError => e
+            say "  ❌ Failed: #{e.message}", :red
+            failed_count += 1
+          end
+          say ''
         end
 
-        # Add run to resultset
-        resultset.add_result(result_path)
         resultset.save(resultset_path)
 
-        say '✅ Added run to resultset', :green
-        say "Path: #{result_path}", :cyan
-        say "ResultSet: #{resultset_path}", :cyan
-        say "Total runs in set: #{resultset.results.count}", :white
+        say '=' * 60, :cyan
+        say 'Summary:', :green
+        say "  Total processed: #{result_paths.size}", :white
+        say "  ✅ Successfully added: #{added_count}", :green
+        say "  ❌ Failed: #{failed_count}", :red if failed_count > 0
+        say "  ⚠️  Skipped: #{skipped_count}", :yellow if skipped_count > 0
+        say "  📊 Total results in set: #{resultset.results.count}", :cyan
+        say '=' * 60, :cyan
+
+        exit 1 if failed_count > 0 && added_count == 0
       rescue StandardError => e
-        say "Error adding run to resultset: #{e.message}", :red
+        say "❌ Error: #{e.message}", :red
         exit 1
       end
 
@@ -93,8 +140,8 @@ module Serialbench
           serialbench resultset remove-result results/sets/performance-comparison results/runs/my-run-local-macos-arm64-ruby-3.3.8
           serialbench resultset remove-result results/sets/cross-platform-test results/runs/my-docker-run
       DESC
-      def remove_result(resultset_path, result_path)
-        store = Serialbench::Models::ResultStore.default
+      def remove_result(resultset_path, _result_path)
+        Serialbench::Models::ResultStore.default
 
         # Find the resultset
         resultset = Serialbench::Models::ResultSet.load(resultset_path)
@@ -136,8 +183,7 @@ module Serialbench
           serialbench resultset build-site results/sets/performance-comparison
           serialbench resultset build-site results/sets/cross-platform-test output/
       DESC
-      option :output_dir, type: :string, default: '_site', desc: 'Output directory for generated site'
-      def build_site(resultset_path)
+      def build_site(resultset_path, output_dir = '_site')
         unless Dir.exist?(resultset_path)
           say "ResultSet directory not found: #{resultset_path}", :red
           say "Please create a resultset first using 'serialbench resultset create'", :white
@@ -156,17 +202,57 @@ module Serialbench
         say "Runs in set: #{resultset.results.size}", :cyan
 
         # Use the unified site generator for resultsets
-        Serialbench::SiteGenerator.generate_for_resultset(resultset, options[:output_dir])
+        Serialbench::SiteGenerator.generate_for_resultset(resultset, output_dir)
 
         say '✅ HTML site generated successfully!', :green
-        say "Site location: #{options[:output_dir]}", :cyan
-        say "Open: #{File.join(options[:output_dir], 'index.html')}", :white
+        say "Site location: #{output_dir}", :cyan
+        say "Open: #{File.join(output_dir, 'index.html')}", :white
       rescue StandardError => e
         say "Error generating site: #{e.message}", :red
         say "Details: #{e.backtrace.first(3).join("\n")}", :red if options[:verbose]
         exit 1
       end
 
+      desc 'export-data RESULTSET_PATH OUTPUT_JSON', 'Export a resultset as the site dashboard JSON payload'
+      long_desc <<~DESC
+        Write the aggregated dashboard payload (combined_results, environments,
+        metadata) for a resultset as JSON. This is the data contract consumed
+        by the Astro site in site/.
+
+        Optionally also export the raw per-environment YAML files and the
+        complete resultset YAML for download links.
+
+        Examples:
+          serialbench resultset export-data results/sets/weekly site/src/data/sample.json --raw-data-dir site/public/data
+      DESC
+      method_option 'raw-data-dir', type: :string,
+                                     desc: 'Also write per-environment YAML and resultset.yaml to this directory'
+      def export_data(resultset_path, output_json)
+        resultset = Serialbench::Models::ResultSet.load(resultset_path)
+
+        if resultset.results.empty?
+          say "ResultSet '#{resultset_path}' contains no runs", :yellow
+          say "Use 'serialbench resultset add-result' to add runs first", :white
+          exit 1
+        end
+
+        payload = Serialbench::SiteGenerator.resultset_payload(resultset)
+        output_dir = File.dirname(File.expand_path(output_json))
+        FileUtils.mkdir_p(output_dir)
+        File.write(output_json, JSON.pretty_generate(payload))
+
+        say "✅ Dashboard payload exported: #{output_json}", :green
+        say "Environments: #{payload['environments'].size}", :cyan
+
+        if options['raw-data-dir']
+          Serialbench::SiteGenerator.export_raw_data(resultset, options['raw-data-dir'])
+          say "📦 Raw YAML exported to: #{options['raw-data-dir']}", :cyan
+        end
+      rescue StandardError => e
+        say "Error exporting data: #{e.message}", :red
+        exit 1
+      end
+
       desc 'list', 'List all available resultsets'
       long_desc <<~DESC
         List all resultsets in the results/sets/ directory.