serialbench 0.1.1 → 0.1.3

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

@@ -7,7 +7,7 @@ module Serialbench
     module Yaml
       # Base class for YAML serializers
       class BaseYamlSerializer < BaseSerializer
-        def format
+        def self.format
           :yaml
         end
 
@@ -41,6 +41,10 @@ module Serialbench
           raise NotImplementedError, 'Streaming not supported by this YAML serializer'
         end
 
+        def supports_generation?
+          true
+        end
+
         private
 
         def require_library(library_name)

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

@@ -31,7 +31,7 @@ module Serialbench
           end
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           require 'psych'
           Psych.dump(object)
         end

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

@@ -11,41 +11,61 @@ module Serialbench
         end
 
         def version
-          return 'N/A' unless available?
+          require 'syck'
+          # Try to get version from gem specification
+          spec = Gem.loaded_specs['syck']
+          return spec.version.to_s if spec
 
-          begin
-            require 'syck'
-            # Try to get version from gem specification
-            spec = Gem.loaded_specs['syck']
-            return spec.version.to_s if spec
-
-            # Fallback to a default version if no gem spec found
-            '1.0.0'
-          rescue
-            'N/A'
-          end
+          # Fallback to a default version if no gem spec found
+          '1.0.0'
+        rescue StandardError
+          'N/A'
         end
 
         def available?
-          begin
-            require 'syck'
-            # Verify that Syck module and methods are actually available
-            defined?(Syck) && Syck.respond_to?(:dump) && Syck.respond_to?(:load)
-          rescue LoadError
-            false
+          require 'syck'
+          # Verify that Syck module and methods are actually available
+          return false unless defined?(Syck) && Syck.respond_to?(:dump) && Syck.respond_to?(:load)
+
+          # Check for known problematic configurations
+          if problematic_environment?
+            warn_about_segfault_issue
+            return false
           end
+
+          true
+        rescue LoadError
+          false
         end
 
         def parse(yaml_string)
           return nil unless available?
-          require 'syck'
-          Syck.load(yaml_string)
+
+          begin
+            require 'syck'
+            Syck.load(yaml_string)
+          rescue StandardError => e
+            if e.message.include?('Segmentation fault') || e.is_a?(SystemExit)
+              handle_segfault_error
+              return nil
+            end
+            raise e
+          end
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           return nil unless available?
-          require 'syck'
-          Syck.dump(object)
+
+          begin
+            require 'syck'
+            Syck.dump(object)
+          rescue StandardError => e
+            if e.message.include?('Segmentation fault') || e.is_a?(SystemExit)
+              handle_segfault_error
+              return nil
+            end
+            raise e
+          end
         end
 
         def supports_streaming?
@@ -59,6 +79,23 @@ module Serialbench
         def description
           'Legacy YAML parser (Ruby < 1.9.3)'
         end
+
+        def problematic_environment?
+          # Ruby 3.1+ has issues with Syck
+          (Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')) &&
+            (Gem::Version.new(version) >= Gem::Version.new('1.4.0'))
+        end
+
+        def warn_about_segfault_issue
+          puts "⚠️  WARNING: The Syck YAML serializer is known to cause segmentation faults with Ruby #{RUBY_VERSION}"
+          puts '   This is a known issue with the syck gem on newer Ruby versions systems.'
+          puts '   Skipping Syck benchmarks to prevent crashes. See README for more details.'
+        end
+
+        def handle_segfault_error
+          puts '❌ ERROR: Syck YAML serializer encountered a segmentation fault'
+          puts "   This is a known issue on Ruby #{RUBY_VERSION}. Skipping remaining Syck tests."
+        end
       end
     end
   end

data/lib/serialbench/serializers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'serializers/base_serializer'
+require_relative 'models/benchmark_result'
 
 # XML Serializers
 require_relative 'serializers/xml/base_xml_serializer'
@@ -26,11 +27,12 @@ require_relative 'serializers/yaml/syck_serializer'
 require_relative 'serializers/toml/base_toml_serializer'
 require_relative 'serializers/toml/toml_rb_serializer'
 require_relative 'serializers/toml/tomlib_serializer'
+require_relative 'serializers/toml/tomlrb_serializer'
 
 module Serialbench
   module Serializers
     # Registry of all available serializers
-    SERIALIZERS = {
+    REGISTER = {
       xml: [
         Xml::RexmlSerializer,
         Xml::OxSerializer,
@@ -50,24 +52,39 @@ module Serialbench
       ],
       toml: [
         Toml::TomlRbSerializer,
-        Toml::TomlibSerializer
+        Toml::TomlibSerializer,
+        Toml::TomlrbSerializer
       ]
     }.freeze
 
     def self.all
-      SERIALIZERS.values.flatten
+      REGISTER.values.flatten.map(&:instance)
     end
 
     def self.for_format(format)
-      SERIALIZERS[format.to_sym] || []
+      REGISTER[format.to_sym]&.map(&:instance) || []
+    end
+
+    def self.information
+      return @information if @information
+
+      @information = available.map do |serializer_singleton|
+        Models::SerializerInformation.new(
+          name: serializer_singleton.name,
+          format: serializer_singleton.format.to_s,
+          version: serializer_singleton.version
+        )
+      end
+
+      @information
     end
 
     def self.available_for_format(format)
-      for_format(format).select { |serializer_class| serializer_class.new.available? }
+      for_format(format).select(&:available?)
     end
 
     def self.available
-      all.select { |serializer_class| serializer_class.new.available? }
+      all.select(&:available?)
     end
   end
 end

data/lib/serialbench/site_generator.rb

@@ -0,0 +1,283 @@
+# 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 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
+
+    # 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 = "#{result.platform.os}-#{result.platform.arch}-ruby-#{result.platform.ruby_version}"
+
+        # 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 = "#{result.platform.os}-#{result.platform.arch}-ruby-#{result.platform.ruby_version}"
+      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