serialbench 0.1.2 → 0.2.0

data/lib/serialbench/serializers/xml/rexml_serializer.rb

@@ -41,7 +41,7 @@ module Serialbench
 
           indent = options.fetch(:indent, 0)
           output = String.new
-          if indent > 0
+          if indent.positive?
             document.write(output, indent)
           else
             document.write(output)
@@ -120,7 +120,7 @@ module Serialbench
           @result = nil
         end
 
-        def start_element(uri, localname, qname, attributes)
+        def start_element(_uri, _localname, qname, attributes)
           @elements_processed += 1
           @block&.call(:start_element, { name: qname, attributes: attributes })
         end
@@ -132,7 +132,7 @@ module Serialbench
           @block&.call(:text, text)
         end
 
-        def end_element(uri, localname, qname)
+        def end_element(_uri, _localname, qname)
           @block&.call(:end_element, { name: qname })
         end
       end

data/lib/serialbench/serializers/yaml/base_yaml_serializer.rb

@@ -16,9 +16,7 @@ module Serialbench
         end
 
         def features
-          features = %w[parsing generation]
-          features << 'streaming' if supports_streaming?
-          features
+          { streaming: supports_streaming? }
         end
 
         # Default YAML generation options

data/lib/serialbench/serializers/yaml/psych_serializer.rb

@@ -31,15 +31,11 @@ module Serialbench
           end
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           require 'psych'
           Psych.dump(object)
         end
 
-        def features
-          %w[parsing generation built-in]
-        end
-
         private
 
         def require_library(library_name)

data/lib/serialbench/serializers/yaml/syck_serializer.rb

@@ -53,7 +53,7 @@ module Serialbench
           end
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           return nil unless available?
 
           begin

data/lib/serialbench/serializers.rb

@@ -10,6 +10,7 @@ require_relative 'serializers/xml/ox_serializer'
 require_relative 'serializers/xml/nokogiri_serializer'
 require_relative 'serializers/xml/oga_serializer'
 require_relative 'serializers/xml/libxml_serializer'
+require_relative 'serializers/xml/leptris_serializer'
 
 # JSON Serializers
 require_relative 'serializers/json/base_json_serializer'
@@ -38,7 +39,8 @@ module Serialbench
         Xml::OxSerializer,
         Xml::NokogiriSerializer,
         Xml::OgaSerializer,
-        Xml::LibxmlSerializer
+        Xml::LibxmlSerializer,
+        Xml::LeptrisSerializer
       ],
       json: [
         Json::JsonSerializer,
@@ -80,11 +82,11 @@ module Serialbench
     end
 
     def self.available_for_format(format)
-      for_format(format).select { |serializer_singleton| serializer_singleton.available? }
+      for_format(format).select(&:available?)
     end
 
     def self.available
-      all.select { |serializer_singleton| serializer_singleton.available? }
+      all.select(&:available?)
     end
   end
 end

data/lib/serialbench/site_generator.rb

@@ -30,22 +30,73 @@ module Serialbench
       generator.generate_site
     end
 
+    def self.resultset_payload(resultset)
+      new(output_path: '/dev/null', resultset: resultset).resultset_payload
+    end
+
+    def self.export_raw_data(resultset, data_dir)
+      new(output_path: '/dev/null', resultset: resultset).export_raw_data_to(data_dir)
+    end
+
+    def resultset_payload
+      transform_resultset_for_dashboard(@resultset)
+        .merge('libraries' => libraries_information(@resultset))
+    end
+
+    # Static capability matrix (adapter declarations) plus the versions
+    # actually measured in this resultset.
+    def libraries_information(resultset)
+      versions = {}
+      resultset.results.each do |result|
+        serializers = result.benchmark_result.serializers || []
+        serializers.each { |si| versions[si.name] ||= si.version }
+      end
+
+      Serialbench::Serializers.all.filter_map do |adapter|
+        next if adapter.name == 'syck'
+
+        features = adapter.features
+        next if features.is_a?(Array)
+
+        {
+          'name' => adapter.name,
+          'format' => adapter.format.to_s,
+          'version' => versions[adapter.name] || 'unknown',
+          'features' => features.transform_values { |v| v == true }
+        }
+      end
+    end
+
+    def export_raw_data_to(data_dir)
+      FileUtils.mkdir_p(data_dir)
+      export_resultset(@resultset, data_dir)
+    end
+
     def generate_site
       target_name = @result ? @result.environment_config.name : @resultset.name
-      data = @result ? @result.to_json : @resultset.to_json
 
       puts "🏗️  Generating HTML site for #{@result ? 'run' : 'resultset'}: #{target_name}"
       puts "Output: #{@output_path}"
 
+      # Transform data for dashboard.js compatibility
+      data = if @result
+               transform_result_for_dashboard(@result)
+             else
+               transform_resultset_for_dashboard(@resultset)
+             end
+
       prepare_output_directory
       render_site(
         {
-          'data' => data,
+          'data' => JSON.generate(data),
           'kind' => @result ? 'run' : 'resultset'
         },
         'format_based.liquid'
       )
 
+      # Export raw data files for download
+      export_raw_data
+
       puts "✅ Site generated successfully at: #{@output_path}"
       @output_path
     end
@@ -101,5 +152,186 @@ module Serialbench
 
       FileUtils.cp_r(assets_source, assets_dest)
     end
+
+    # Transform a single Result into dashboard-compatible format
+    # Dashboard expects: { combined_results: {...}, environments: {...}, metadata: {...} }
+    def transform_result_for_dashboard(result)
+      env_key = "env-#{result.platform.ruby_version}"
+
+      # Build combined_results structure
+      combined_results = build_combined_results(result, env_key)
+
+      # Build environments structure
+      environments = {
+        env_key => {
+          'ruby_version' => result.platform.ruby_version,
+          'ruby_platform' => result.platform.ruby_platform || "#{result.platform.os}-#{result.platform.arch}",
+          'os' => result.platform.os,
+          'arch' => result.platform.arch,
+          'source_file' => result.metadata.environment_config_path,
+          'timestamp' => result.metadata.created_at
+        }
+      }
+
+      {
+        'combined_results' => combined_results,
+        'environments' => environments,
+        'metadata' => {
+          'generated_at' => Time.now.iso8601
+        }
+      }
+    end
+
+    # Environment identity for the site: use the CI platform_string
+    # ("macos-26-ruby-3.4") when it is runner-shaped, so each runner label is
+    # its own environment; fall back to os-arch for other sources (docker,
+    # local runs, older resultsets).
+    def env_identity(result)
+      platform_string = result.platform.platform_string
+      ruby = result.platform.ruby_version
+      return platform_string if platform_string&.end_with?("-ruby-#{ruby}")
+
+      "#{result.platform.os}-#{result.platform.arch}-ruby-#{ruby}"
+    end
+
+    # Transform a ResultSet (collection of Results) into dashboard-compatible format
+    # Combines all results into a single dashboard structure
+    def transform_resultset_for_dashboard(resultset)
+      combined_results = {}
+      environments = {}
+
+      resultset.results.each do |result|
+        # Create unique env key for this result
+        env_key = env_identity(result)
+
+        # Merge this result's data into combined_results
+        result_combined = build_combined_results(result, env_key)
+        merge_combined_results!(combined_results, result_combined)
+
+        # Add environment info
+        environments[env_key] = {
+          'ruby_version' => result.platform.ruby_version,
+          'ruby_platform' => result.platform.ruby_platform || "#{result.platform.os}-#{result.platform.arch}",
+          'os' => result.platform.os,
+          'arch' => result.platform.arch,
+          'source_file' => result.metadata.environment_config_path,
+          'timestamp' => result.metadata.created_at
+        }
+      end
+
+      {
+        'combined_results' => combined_results,
+        'environments' => environments,
+        'metadata' => {
+          'resultset_name' => resultset.name,
+          'resultset_description' => resultset.description,
+          'total_runs' => resultset.results.size,
+          'generated_at' => Time.now.iso8601
+        }
+      }
+    end
+
+    # Deep merge results from multiple runs
+    def merge_combined_results!(target, source)
+      source.each do |operation, sizes|
+        target[operation] ||= {}
+        sizes.each do |size, formats|
+          target[operation][size] ||= {}
+          formats.each do |format, serializers|
+            target[operation][size][format] ||= {}
+            serializers.each do |serializer, envs|
+              target[operation][size][format][serializer] ||= {}
+              target[operation][size][format][serializer].merge!(envs)
+            end
+          end
+        end
+      end
+    end
+
+    def build_combined_results(result, env_key)
+      combined = {}
+
+      %w[parsing generation streaming].each do |operation|
+        combined[operation] = {}
+
+        operation_results = result.benchmark_result.send(operation)
+        next if operation_results.nil? || operation_results.empty?
+
+        operation_results.each do |perf|
+          size = perf.data_size
+          format = perf.format
+          serializer = perf.adapter
+
+          combined[operation][size] ||= {}
+          combined[operation][size][format] ||= {}
+          combined[operation][size][format][serializer] ||= {}
+          combined[operation][size][format][serializer][env_key] = {
+            'iterations_per_second' => perf.iterations_per_second,
+            'time_per_iteration' => perf.time_per_iteration
+          }
+        end
+      end
+
+      # Handle memory separately
+      if result.benchmark_result.memory && !result.benchmark_result.memory.empty?
+        combined['memory'] = {}
+
+        result.benchmark_result.memory.each do |mem|
+          size = mem.data_size
+          format = mem.format
+          serializer = mem.adapter
+
+          combined['memory'][size] ||= {}
+          combined['memory'][size][format] ||= {}
+          combined['memory'][size][format][serializer] ||= {}
+          combined['memory'][size][format][serializer][env_key] = {
+            'allocated_memory' => mem.allocated_memory,
+            'retained_memory' => mem.retained_memory
+          }
+        end
+      end
+
+      combined
+    end
+
+    # Export raw data files for download
+    def export_raw_data
+      data_dir = File.join(@output_path, 'data')
+      FileUtils.mkdir_p(data_dir)
+
+      if @result
+        # Export single result
+        export_single_result(@result, data_dir)
+      elsif @resultset
+        # Export all results in resultset plus the complete resultset
+        export_resultset(@resultset, data_dir)
+      end
+
+      puts "📦 Raw data files exported to: #{data_dir}"
+    end
+
+    def export_single_result(result, data_dir)
+      # Create filename based on platform info
+      env_key = env_identity(result)
+      filename = "#{env_key}.yaml"
+      filepath = File.join(data_dir, filename)
+
+      # Write result as YAML
+      File.write(filepath, result.to_yaml)
+      puts "   📄 Exported: #{filename}"
+    end
+
+    def export_resultset(resultset, data_dir)
+      # Export each individual result
+      resultset.results.each do |result|
+        export_single_result(result, data_dir)
+      end
+
+      # Export complete resultset
+      resultset_filename = 'resultset.yaml'
+      resultset_filepath = File.join(data_dir, resultset_filename)
+      File.write(resultset_filepath, resultset.to_yaml)
+      puts "   📄 Exported: #{resultset_filename} (complete dataset)"
+    end
   end
 end

data/lib/serialbench/templates/assets/css/format_based.css

@@ -13,59 +13,7 @@
     flex-wrap: wrap;
 }
 
-.format-tab {
-    padding: 12px 24px;
-    border: none;
-    background: var(--card-bg);
-    color: var(--text-color);
-    border-radius: 25px;
-    cursor: pointer;
-    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-    font-weight: 600;
-    font-size: 0.95em;
-    box-shadow: var(--shadow-soft);
-    border: 2px solid transparent;
-    position: relative;
-    overflow: hidden;
-}
-
-.format-tab::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: -100%;
-    width: 100%;
-    height: 100%;
-    background: var(--gradient-accent);
-    transition: left 0.3s ease;
-    z-index: 0;
-}
-
-.format-tab:hover {
-    transform: translateY(-3px);
-    box-shadow: var(--shadow-medium);
-    border-color: var(--secondary-color);
-}
-
-.format-tab:hover::before {
-    left: 0;
-}
-
-.format-tab > * {
-    position: relative;
-    z-index: 1;
-}
-
-.format-tab.active {
-    background: var(--gradient-primary);
-    color: white;
-    transform: translateY(-2px);
-    box-shadow: var(--shadow-medium);
-}
-
-.format-tab.active::before {
-    display: none;
-}
+/* Format tab styles are defined in themes.css */
 
 /* Format Content */
 .format-content {

data/lib/serialbench/templates/assets/css/themes.css

@@ -259,7 +259,7 @@ body {
 
 .format-tab {
   padding: var(--space-sm) var(--space-lg);
-  background: transparent;
+  background: var(--bg-card);
   border: 1px solid var(--border-primary);
   border-radius: var(--radius-md);
   color: var(--text-secondary);
@@ -271,14 +271,15 @@ body {
   letter-spacing: 0.05em;
 }
 
-.format-tab:hover {
-  background: var(--bg-hover);
+.format-tab:hover:not(.active) {
+  background: var(--bg-tertiary);
   color: var(--text-primary);
+  border-color: var(--border-secondary);
   transform: translateY(-1px);
 }
 
 .format-tab.active {
-  background: var(--gradient-primary);
+  background: var(--accent-primary);
   border-color: var(--accent-primary);
   color: white;
   box-shadow: var(--shadow-md);

data/lib/serialbench/templates/assets/js/chart_helpers.js

@@ -172,9 +172,15 @@ function createPerformanceChart(canvasId, title, data, metric, environments) {
     console.log(`🌍 Environments:`, environments);
     console.log(`📊 Raw data:`, data);
 
+    // Get theme-aware colors
+    const isDarkMode = document.documentElement.getAttribute('data-theme') === 'dark';
+    const textColor = getComputedStyle(document.documentElement).getPropertyValue('--text-primary').trim() || (isDarkMode ? '#F8FAFC' : '#0F172A');
+    const gridColor = getComputedStyle(document.documentElement).getPropertyValue('--border-primary').trim() || (isDarkMode ? '#475569' : '#E2E8F0');
+
+    // High contrast color palette
     const colors = [
-        '#6366f1', '#8b5cf6', '#06b6d4', '#10b981', '#f59e0b',
-        '#ef4444', '#ec4899', '#84cc16', '#f97316', '#6b7280'
+        '#F97316', '#3B82F6', '#10B981', '#EF4444', '#8B5CF6',
+        '#F59E0B', '#EC4899', '#06B6D4', '#84CC16', '#6366F1'
     ];
 
     const datasets = serializers.map((serializer, index) => {
@@ -224,14 +230,15 @@ function createPerformanceChart(canvasId, title, data, metric, environments) {
                         display: true,
                         text: title,
                         font: { size: 16, weight: 'bold' },
-                        color: '#374151'
+                        color: textColor
                     },
                     legend: {
                         position: 'top',
                         labels: {
                             usePointStyle: true,
                             padding: 20,
-                            font: { size: 12 }
+                            font: { size: 12 },
+                            color: textColor
                         }
                     }
                 },
@@ -241,17 +248,25 @@ function createPerformanceChart(canvasId, title, data, metric, environments) {
                         title: {
                             display: true,
                             text: 'Iterations per Second',
-                            font: { size: 12, weight: 'bold' }
+                            font: { size: 12, weight: 'bold' },
+                            color: textColor
+                        },
+                        ticks: {
+                            color: textColor
                         },
                         grid: {
-                            color: '#f3f4f6'
+                            color: gridColor
                         }
                     },
                     x: {
                         title: {
                             display: true,
                             text: 'Ruby Versions',
-                            font: { size: 12, weight: 'bold' }
+                            font: { size: 12, weight: 'bold' },
+                            color: textColor
+                        },
+                        ticks: {
+                            color: textColor
                         },
                         grid: {
                             display: false
@@ -294,9 +309,15 @@ function createMemoryChart(canvasId, title, data, environments) {
         return;
     }
 
+    // Get theme-aware colors
+    const isDarkMode = document.documentElement.getAttribute('data-theme') === 'dark';
+    const textColor = getComputedStyle(document.documentElement).getPropertyValue('--text-primary').trim() || (isDarkMode ? '#F8FAFC' : '#0F172A');
+    const gridColor = getComputedStyle(document.documentElement).getPropertyValue('--border-primary').trim() || (isDarkMode ? '#475569' : '#E2E8F0');
+
+    // High contrast color palette
     const colors = [
-        '#6366f1', '#8b5cf6', '#06b6d4', '#10b981', '#f59e0b',
-        '#ef4444', '#ec4899', '#84cc16', '#f97316', '#6b7280'
+        '#F97316', '#3B82F6', '#10B981', '#EF4444', '#8B5CF6',
+        '#F59E0B', '#EC4899', '#06B6D4', '#84CC16', '#6366F1'
     ];
 
     const datasets = serializers.map((serializer, index) => {
@@ -338,14 +359,15 @@ function createMemoryChart(canvasId, title, data, environments) {
                         display: true,
                         text: title,
                         font: { size: 16, weight: 'bold' },
-                        color: '#374151'
+                        color: textColor
                     },
                     legend: {
                         position: 'top',
                         labels: {
                             usePointStyle: true,
                             padding: 20,
-                            font: { size: 12 }
+                            font: { size: 12 },
+                            color: textColor
                         }
                     }
                 },
@@ -355,17 +377,25 @@ function createMemoryChart(canvasId, title, data, environments) {
                         title: {
                             display: true,
                             text: 'Memory Usage (MB)',
-                            font: { size: 12, weight: 'bold' }
+                            font: { size: 12, weight: 'bold' },
+                            color: textColor
+                        },
+                        ticks: {
+                            color: textColor
                         },
                         grid: {
-                            color: '#f3f4f6'
+                            color: gridColor
                         }
                     },
                     x: {
                         title: {
                             display: true,
                             text: 'Ruby Versions',
-                            font: { size: 12, weight: 'bold' }
+                            font: { size: 12, weight: 'bold' },
+                            color: textColor
+                        },
+                        ticks: {
+                            color: textColor
                         },
                         grid: {
                             display: false

data/lib/serialbench/templates/assets/js/dashboard.js

@@ -108,7 +108,9 @@ class SerialBenchDashboard {
 
         if (this.data.environments) {
             Object.values(this.data.environments).forEach(env => {
-                platforms.add(env.ruby_platform);
+                // Use os-arch combination instead of ruby_platform
+                const platformKey = `${env.os}-${env.arch}`;
+                platforms.add(platformKey);
                 rubyVersions.add(env.ruby_version);
             });
         }
@@ -120,7 +122,7 @@ class SerialBenchDashboard {
             Array.from(platforms).sort().forEach(platform => {
                 const option = document.createElement('option');
                 option.value = platform;
-                option.textContent = this.formatPlatformName(platform);
+                option.textContent = platform;
                 platformSelect.appendChild(option);
             });
         }
@@ -148,15 +150,6 @@ class SerialBenchDashboard {
         }
     }
 
-    formatPlatformName(platform) {
-        const platformMap = {
-            'aarch64-linux': 'ARM64 Linux',
-            'x86_64-linux': 'x64 Linux',
-            'x86_64-darwin': 'x64 macOS',
-            'aarch64-darwin': 'ARM64 macOS'
-        };
-        return platformMap[platform] || platform;
-    }
 
     setupFilterEventListeners() {
         // Platform filter
@@ -213,7 +206,9 @@ class SerialBenchDashboard {
         // Set all platforms and versions by default
         if (this.data.environments) {
             Object.values(this.data.environments).forEach(env => {
-                this.filters.platforms.add(env.ruby_platform);
+                // Use os-arch combination instead of ruby_platform
+                const platformKey = `${env.os}-${env.arch}`;
+                this.filters.platforms.add(platformKey);
                 this.filters.rubyVersions.add(env.ruby_version);
             });
         }
@@ -336,8 +331,10 @@ class SerialBenchDashboard {
     shouldIncludeEnvironment(env) {
         if (!env) return false;
 
+        // Use os-arch combination for platform matching
+        const platformKey = `${env.os}-${env.arch}`;
         const platformMatch = this.filters.platforms.size === 0 ||
-                             this.filters.platforms.has(env.ruby_platform);
+                             this.filters.platforms.has(platformKey);
         const versionMatch = this.filters.rubyVersions.size === 0 ||
                             this.filters.rubyVersions.has(env.ruby_version);
 
@@ -634,8 +631,10 @@ class SerialBenchDashboard {
         // Show all environments, but apply platform and version filters only (not format)
         const filteredEnvs = Object.entries(this.data.environments)
             .filter(([key, env]) => {
+                // Use os-arch combination for platform matching
+                const platformKey = `${env.os}-${env.arch}`;
                 const platformMatch = this.filters.platforms.size === 0 ||
-                                     this.filters.platforms.has(env.ruby_platform);
+                                     this.filters.platforms.has(platformKey);
                 const versionMatch = this.filters.rubyVersions.size === 0 ||
                                     this.filters.rubyVersions.has(env.ruby_version);
                 return platformMatch && versionMatch;
@@ -649,7 +648,7 @@ class SerialBenchDashboard {
         container.innerHTML = filteredEnvs.map(([key, env]) => `
             <div class="environment-card fade-in-up">
                 <h3 class="environment-card-title">
-                    Ruby ${env.ruby_version} on ${this.formatPlatformName(env.ruby_platform)}
+                    Ruby ${env.ruby_version} on ${env.os}-${env.arch}
                 </h3>
                 <p><strong>Source:</strong> ${env.source_file ? env.source_file.split('/').pop() : 'Unknown'}</p>
                 <p><strong>Timestamp:</strong> ${new Date(env.timestamp).toLocaleString()}</p>