serialbench 0.3.1 → 0.4.0

data/lib/serialbench/site_generator.rb

@@ -1,337 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'erb'
-require 'json'
-require 'liquid'
-require 'yaml'
-
-module Serialbench
-  # Unified site generator for creating static HTML sites from benchmark results
-  class SiteGenerator
-    TEMPLATE_DIR = File.join(__dir__, 'templates')
-
-    attr_reader :output_path, :result, :resultset
-
-    def initialize(output_path:, result: nil, resultset: nil)
-      @output_path = File.expand_path(output_path)
-      @result = result if result
-      @resultset = resultset if resultset
-      setup_liquid_environment
-    end
-
-    def self.generate_for_result(result, output_path)
-      generator = new(output_path: output_path, result: result)
-      generator.generate_site
-    end
-
-    def self.generate_for_resultset(resultset, output_path)
-      generator = new(output_path: output_path, resultset: resultset)
-      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
-
-      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' => 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
-
-    private
-
-    def setup_liquid_environment
-      @liquid_env = Liquid::Environment.new
-      @liquid_env.file_system = Liquid::LocalFileSystem.new(TEMPLATE_DIR)
-    end
-
-    def prepare_output_directory
-      if Dir.exist?(@output_path)
-        puts 'Cleaning existing output directory...'
-        FileUtils.rm_rf(Dir.glob(File.join(@output_path, '*')))
-      else
-        FileUtils.mkdir_p(@output_path)
-      end
-    end
-
-    def render_site(template_data, template_name)
-      # Load and render content template
-      content_template = load_template(template_name)
-      content = content_template.render(template_data)
-
-      # Load and render base template
-      base_template = load_template('base.liquid')
-      html = base_template.render(template_data.merge('content' => content))
-
-      # Write HTML file
-      write_file(html, 'index.html')
-
-      # Copy assets
-      copy_assets
-    end
-
-    def load_template(template_name)
-      template_path = File.join(TEMPLATE_DIR, template_name)
-      template_content = File.read(template_path)
-      Liquid::Template.parse(template_content)
-    end
-
-    def write_file(content, filename)
-      FileUtils.mkdir_p(@output_path)
-      File.write(File.join(@output_path, filename), content)
-    end
-
-    def copy_assets
-      assets_source = File.join(TEMPLATE_DIR, 'assets')
-      assets_dest = File.join(@output_path, 'assets')
-
-      return unless Dir.exist?(assets_source)
-
-      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