serialbench 0.1.0 → 0.1.2

data/lib/serialbench/serializers/toml/tomlrb_serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'base_toml_serializer'
+
+module Serialbench
+  module Serializers
+    module Toml
+      class TomlrbSerializer < BaseTomlSerializer
+        def available?
+          require_library('tomlrb')
+        end
+
+        def name
+          'tomlrb'
+        end
+
+        def version
+          require 'tomlrb'
+          # tomlrb doesn't expose a VERSION constant, so we'll use gem version
+          Gem.loaded_specs['tomlrb']&.version&.to_s || 'unknown'
+        rescue LoadError, NameError
+          'unknown'
+        end
+
+        def parse(toml_string)
+          require 'tomlrb'
+          Tomlrb.parse(toml_string)
+        end
+
+        def generate(object, options = {})
+          raise NotImplementedError, 'tomlrb gem does not support TOML generation/dumping'
+        end
+
+        def supports_generation?
+          false
+        end
+
+        def supports_comments?
+          false
+        end
+
+        def supports_arrays_of_tables?
+          true
+        end
+
+        def supports_inline_tables?
+          true
+        end
+
+        def supports_multiline_strings?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Serialbench
   module Serializers
     module Xml
       class BaseXmlSerializer < BaseSerializer
-        def format
+        def self.format
           :xml
         end
 
@@ -33,7 +33,9 @@ module Serialbench
           }
         end
 
-        protected
+        def supports_generation?
+          true
+        end
 
         def supports_xpath?
           false
@@ -47,13 +49,6 @@ module Serialbench
           false
         end
 
-        # Subclasses should override this to specify their library name
-        def library_require_name
-          raise NotImplementedError, 'Subclasses must implement #library_require_name'
-        end
-
-        public
-
         # Check if the XML library is available
         def available?
           return @available if defined?(@available)

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

@@ -49,8 +49,6 @@ module Serialbench
           LibXML::XML::VERSION
         end
 
-        protected
-
         def library_require_name
           'libxml'
         end

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

@@ -49,8 +49,6 @@ module Serialbench
           Nokogiri::VERSION
         end
 
-        protected
-
         def library_require_name
           'nokogiri'
         end
@@ -60,9 +58,9 @@ module Serialbench
         def build_xml_from_data(xml, data, root_name = 'root')
           case data
           when Hash
-            xml.send(root_name) do
+            xml.send(sanitize_element_name(root_name)) do
               data.each do |key, value|
-                build_xml_from_data(xml, value, key)
+                build_xml_from_data(xml, value, sanitize_element_name(key.to_s))
               end
             end
           when Array
@@ -70,10 +68,28 @@ module Serialbench
               build_xml_from_data(xml, item, "item_#{index}")
             end
           else
-            xml.send(root_name, data.to_s)
+            # Use a safe method that always works
+            element_name = sanitize_element_name(root_name)
+            if xml.respond_to?(element_name)
+              xml.send(element_name, data.to_s)
+            else
+              # Fallback: create element manually
+              xml.tag!(element_name, data.to_s)
+            end
           end
         end
 
+        def sanitize_element_name(name)
+          # Ensure element name is valid XML and safe to use as method name
+          sanitized = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+          # Ensure it starts with a letter
+          sanitized = "element_#{sanitized}" if sanitized.empty? || sanitized =~ /\A\d/
+          # Avoid conflicts with common Nokogiri methods
+          reserved_words = %w[text comment cdata parent children attributes namespace]
+          sanitized = "data_#{sanitized}" if reserved_words.include?(sanitized)
+          sanitized
+        end
+
         # SAX handler for streaming
         class StreamingHandler
           attr_reader :elements_processed

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

@@ -49,8 +49,6 @@ module Serialbench
           Oga::VERSION
         end
 
-        protected
-
         def library_require_name
           'oga'
         end

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

@@ -40,8 +40,6 @@ module Serialbench
           Ox::VERSION
         end
 
-        protected
-
         def library_require_name
           'ox'
         end

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

@@ -26,8 +26,19 @@ module Serialbench
           REXML::Document.new(xml_string)
         end
 
-        def generate(document, options = {})
+        def generate(data, options = {})
           require 'rexml/document'
+
+          # If data is already a REXML::Document, use it directly
+          if data.is_a?(REXML::Document)
+            document = data
+          else
+            # Convert Hash/other data to XML document
+            document = REXML::Document.new
+            root = document.add_element('root')
+            hash_to_xml(data, root)
+          end
+
           indent = options.fetch(:indent, 0)
           output = String.new
           if indent > 0
@@ -63,11 +74,9 @@ module Serialbench
         end
 
         def supports_streaming?
-          true
+          false
         end
 
-        protected
-
         def supports_xpath?
           true
         end
@@ -79,6 +88,25 @@ module Serialbench
         def supports_validation?
           false
         end
+
+        private
+
+        def hash_to_xml(data, parent)
+          case data
+          when Hash
+            data.each do |key, value|
+              element = parent.add_element(key.to_s)
+              hash_to_xml(value, element)
+            end
+          when Array
+            data.each_with_index do |item, index|
+              element = parent.add_element("item_#{index}")
+              hash_to_xml(item, element)
+            end
+          else
+            parent.text = data.to_s
+          end
+        end
       end
 
       # SAX handler for REXML streaming

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../base_serializer'
+
+module Serialbench
+  module Serializers
+    module Yaml
+      # Base class for YAML serializers
+      class BaseYamlSerializer < BaseSerializer
+        def self.format
+          :yaml
+        end
+
+        def supports_streaming?
+          false # Most YAML parsers don't support streaming
+        end
+
+        def features
+          features = %w[parsing generation]
+          features << 'streaming' if supports_streaming?
+          features
+        end
+
+        # Default YAML generation options
+        def default_generation_options
+          {}
+        end
+
+        # Parse YAML string into Ruby object
+        def parse(yaml_string)
+          raise NotImplementedError, 'Subclasses must implement parse method'
+        end
+
+        # Generate YAML string from Ruby object
+        def generate(object, options = {})
+          raise NotImplementedError, 'Subclasses must implement generate method'
+        end
+
+        # Stream parse YAML (if supported)
+        def stream_parse(yaml_string, &block)
+          raise NotImplementedError, 'Streaming not supported by this YAML serializer'
+        end
+
+        def supports_generation?
+          true
+        end
+
+        private
+
+        def require_library(library_name)
+          require library_name
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base_yaml_serializer'
+
+module Serialbench
+  module Serializers
+    module Yaml
+      # Psych YAML serializer - Ruby's built-in YAML parser
+      class PsychSerializer < BaseYamlSerializer
+        def available?
+          require_library('psych')
+        end
+
+        def name
+          'psych'
+        end
+
+        def version
+          require 'psych'
+          Psych::VERSION
+        end
+
+        def parse(yaml_string)
+          require 'psych'
+          # Handle Ruby version compatibility for permitted_classes parameter
+          if RUBY_VERSION >= '3.1.0'
+            Psych.load(yaml_string, permitted_classes: [Date, Time, Symbol])
+          else
+            # For older Ruby versions, use the old API
+            Psych.load(yaml_string)
+          end
+        end
+
+        def generate(object, options = {})
+          require 'psych'
+          Psych.dump(object)
+        end
+
+        def features
+          %w[parsing generation built-in]
+        end
+
+        private
+
+        def require_library(library_name)
+          require library_name
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'base_yaml_serializer'
+
+module Serialbench
+  module Serializers
+    module Yaml
+      class SyckSerializer < BaseYamlSerializer
+        def name
+          'syck'
+        end
+
+        def version
+          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 StandardError
+          'N/A'
+        end
+
+        def available?
+          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?
+
+          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 = {})
+          return nil unless available?
+
+          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?
+          false
+        end
+
+        def features
+          %w[parsing generation legacy]
+        end
+
+        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
+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'
@@ -15,16 +16,23 @@ require_relative 'serializers/json/base_json_serializer'
 require_relative 'serializers/json/json_serializer'
 require_relative 'serializers/json/oj_serializer'
 require_relative 'serializers/json/yajl_serializer'
+require_relative 'serializers/json/rapidjson_serializer'
+
+# YAML Serializers
+require_relative 'serializers/yaml/base_yaml_serializer'
+require_relative 'serializers/yaml/psych_serializer'
+require_relative 'serializers/yaml/syck_serializer'
 
 # TOML Serializers
 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,
@@ -35,28 +43,48 @@ module Serialbench
       json: [
         Json::JsonSerializer,
         Json::OjSerializer,
+        Json::RapidjsonSerializer,
         Json::YajlSerializer
       ],
+      yaml: [
+        Yaml::PsychSerializer,
+        Yaml::SyckSerializer
+      ],
       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 { |serializer_singleton| serializer_singleton.available? }
     end
 
     def self.available
-      all.select { |serializer_class| serializer_class.new.available? }
+      all.select { |serializer_singleton| serializer_singleton.available? }
     end
   end
 end

data/lib/serialbench/site_generator.rb

@@ -0,0 +1,105 @@
+# 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
+      data = @result ? @result.to_json : @resultset.to_json
+
+      puts "🏗️  Generating HTML site for #{@result ? 'run' : 'resultset'}: #{target_name}"
+      puts "Output: #{@output_path}"
+
+      prepare_output_directory
+      render_site(
+        {
+          'data' => data,
+          'kind' => @result ? 'run' : 'resultset'
+        },
+        'format_based.liquid'
+      )
+
+      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
+  end
+end