serialbench 0.1.3 → 0.3.1

data/config/benchmarks/full-xml.yml

@@ -0,0 +1,26 @@
+# Per-format split of full.yml: each format runs in its own process so
+# memory profiling of large documents cannot compound across formats
+# (windows runners OOMed with all four formats in one process).
+name: full-xml
+
+data_sizes:
+- small
+- medium
+- large
+
+formats:
+- xml
+
+iterations:
+  small: 10
+  medium: 3
+  large: 1
+
+operations:
+- parse
+- generate
+- streaming
+- xpath
+- memory
+
+warmup: 2

data/config/benchmarks/full-yaml.yml

@@ -0,0 +1,25 @@
+# Per-format split of full.yml: each format runs in its own process so
+# memory profiling of large documents cannot compound across formats
+# (windows runners OOMed with all four formats in one process).
+name: full-yaml
+
+data_sizes:
+- small
+- medium
+- large
+
+formats:
+- yaml
+
+iterations:
+  small: 10
+  medium: 3
+  large: 1
+
+operations:
+- parse
+- generate
+- streaming
+- memory
+
+warmup: 2

data/config/benchmarks/full.yml

@@ -15,15 +15,20 @@ formats:
 - yaml
 - toml
 
+# Trimmed from 20/5/2 (warmup 3): a healthy leg took ~70 minutes at that
+# setting, which both inflates weekly cost and leaves legs exposed to
+# runner-eviction flakiness. 10/3/1 with warmup 2 halves runtime with
+# acceptable added noise.
 iterations:
-  small: 20
-  medium: 5
-  large: 2
+  small: 10
+  medium: 3
+  large: 1
 
 operations:
 - parse
 - generate
 - streaming
+- xpath
 - memory
 
-warmup: 3
+warmup: 2

data/lib/serialbench/benchmark_runner.rb

@@ -24,6 +24,19 @@ module Serialbench
       load_test_data
     end
 
+    # Each operation maps to a lambda. Adding an operation = one entry.
+    OPERATIONS = {
+      'parsing' => ->(s, data) { s.parse(data) },
+      'generation' => ->(s, data) { s.generate(s.parse(data)) },
+      'xpath' => lambda { |s, data|
+        doc = s.parse(data)
+        s.xpath_query(doc, '//book')
+        s.xpath_query(doc, "//book[@id='101']")
+        s.xpath_query(doc, '//book[price > 30]/title')
+      },
+      'streaming' => ->(s, data) { s.stream_parse(data) { |_event, _data| } },
+    }.freeze
+
     def run_all_benchmarks
       puts 'Serialbench - Running comprehensive serialization performance tests'
       puts '=' * 70
@@ -32,34 +45,18 @@ module Serialbench
       puts "Test data sizes: #{@test_data.keys.join(', ')}"
       puts
 
+      results = {}
+      OPERATIONS.each do |name, handler|
+        results[name.to_sym] = run_benchmark_type(name, name, &handler)
+      end
+      results[:memory] = run_memory_benchmarks
+
       Models::BenchmarkResult.new(
         serializers: Serializers.information,
-        parsing: run_parsing_benchmarks,
-        generation: run_generation_benchmarks,
-        memory: run_memory_benchmarks,
-        streaming: run_streaming_benchmarks
+        **results
       )
     end
 
-    def run_parsing_benchmarks
-      run_benchmark_type('parsing', 'parse') do |serializer, data|
-        serializer.parse(data)
-      end
-    end
-
-    def run_generation_benchmarks
-      run_benchmark_type('generation', 'generation') do |serializer, data|
-        document = serializer.parse(data)
-        serializer.generate(document)
-      end
-    end
-
-    def run_streaming_benchmarks
-      run_benchmark_type('streaming', 'stream parse') do |serializer, data|
-        serializer.stream_parse(data) { |event, data| }
-      end
-    end
-
     def run_memory_benchmarks
       puts "\nRunning memory usage benchmarks..."
       return [] unless defined?(::MemoryProfiler)

data/lib/serialbench/cli/benchmark_cli.rb

@@ -190,7 +190,7 @@ module Serialbench
         say "🏗️  Generating HTML site for result: #{result_path}", :green
 
         # Use the unified site generator for results
-        Serialbench::SiteGenerator.generate_for_result(result, options[:output_dir])
+        puts 'Site generation moved to serialbench.github.io'
 
         say '✅ HTML site generated successfully!', :green
         say "Site location: #{options[:output_dir]}", :cyan

data/lib/serialbench/cli/resultset_cli.rb

@@ -213,6 +213,46 @@ module Serialbench
         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.

data/lib/serialbench/cli.rb

@@ -4,9 +4,9 @@ require 'thor'
 require_relative 'cli/base_cli'
 require_relative 'cli/environment_cli'
 require_relative 'cli/benchmark_cli'
-require_relative 'cli/resultset_cli'
 require_relative 'cli/ruby_build_cli'
 require_relative 'cli/validate_cli'
+require_relative 'cli/resultset_cli'
 
 module Serialbench
   # Main CLI entry point for the new object-oriented command structure
@@ -17,9 +17,6 @@ module Serialbench
     desc 'benchmark SUBCOMMAND', 'Manage individual benchmark runs'
     subcommand 'benchmark', Serialbench::Cli::BenchmarkCli
 
-    desc 'resultset SUBCOMMAND', 'Manage benchmark resultsets (collections of runs)'
-    subcommand 'resultset', Serialbench::Cli::ResultsetCli
-
     desc 'ruby_build SUBCOMMAND', 'Manage Ruby-Build definitions for validation'
     subcommand 'ruby_build', Serialbench::Cli::RubyBuildCli
 
@@ -45,7 +42,6 @@ module Serialbench
           COMMANDS:
             environment   Manage benchmark environments (Docker, ASDF, Local)
             benchmark     Manage individual benchmark runs
-            resultset     Manage benchmark resultsets (collections of runs)
             ruby-build    Manage Ruby-Build definitions for validation
             version       Show version information
             help          Show this help message
@@ -63,12 +59,9 @@ module Serialbench
             serialbench benchmark execute my-benchmark.yml
 
             # Create a result set for comparison
-            serialbench resultset create comparison-set
-            serialbench resultset add-result comparison-set results/my-benchmark
 
             # Generate static sites
             serialbench benchmark build-site results/my-benchmark
-            serialbench resultset build-site resultsets/comparison-set
 
           For detailed help on any command, use:
             serialbench COMMAND help

data/lib/serialbench/models/benchmark_result.rb

@@ -68,6 +68,7 @@ module Serialbench
       attribute :generation, IterationPerformance, collection: true
       attribute :memory, MemoryPerformance, collection: true
       attribute :streaming, IterationPerformance, collection: true
+      attribute :xpath, IterationPerformance, collection: true
 
       key_value do
         map 'serializers', to: :serializers
@@ -75,6 +76,7 @@ module Serialbench
         map 'generation', to: :generation
         map 'memory', to: :memory
         map 'streaming', to: :streaming
+        map 'xpath', to: :xpath
       end
     end
   end

data/lib/serialbench/models/platform.rb

@@ -15,8 +15,11 @@ module Serialbench
     class Platform < Lutaml::Model::Serializable
       attribute :platform_string, :string
       attribute :kind, :string, default: -> { 'local' }
-      attribute :os, :string, default: -> { detect_os }
-      attribute :arch, :string, default: -> { detect_arch }
+      # Fully qualified: lutaml-model 0.8+ instance-evals default
+      # lambdas, so bare detect_os/detect_arch (class methods) no
+      # longer resolve there.
+      attribute :os, :string, default: -> { Serialbench::Models::Platform.detect_os }
+      attribute :arch, :string, default: -> { Serialbench::Models::Platform.detect_arch }
       attribute :ruby_version, :string, default: -> { RUBY_VERSION }
       attribute :ruby_platform, :string, default: -> { RUBY_PLATFORM }
       attribute :ruby_build_tag, :string

data/lib/serialbench/serializers/base_serializer.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 # frozen_string_literal: true
 
 require 'singleton'
@@ -33,9 +35,19 @@ module Serialbench
         result
       end
 
+      # Capabilities: a Set of symbols declaring what this adapter can do.
+      # Subclasses override to add symbols; the base handles every query.
+      # This replaces the 12+ individual supports_X? predicates.
+      def capabilities
+        Set.new(%i[dom parse generate])
+      end
+
+      def supports?(capability)
+        capabilities.include?(capability)
+      end
+
       def supports_streaming?
-        # Override in subclasses that support streaming
-        false
+        supports?(:sax) || supports?(:streaming)
       end
 
       def require_library(library_name)

data/lib/serialbench/serializers/json/rapidjson_serializer.rb

@@ -32,10 +32,6 @@ module Serialbench
           RapidJSON.dump(object)
         end
 
-        def features
-          %w[parsing generation high-performance c-extension]
-        end
-
         private
 
         def require_library(library_name)

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

@@ -23,13 +23,14 @@ module Serialbench
           generate(document, options)
         end
 
-        # XML-specific features
+        # XML-specific features derive from the capability set
         def features
           {
-            xpath: supports_xpath?,
-            namespaces: supports_namespaces?,
-            validation: supports_validation?,
-            streaming: supports_streaming?
+            xpath: supports?(:xpath),
+            namespaces: supports?(:namespaces),
+            validation: supports?(:validation),
+            streaming: supports?(:sax) || supports?(:streaming),
+            stax: supports?(:stax)
           }
         end
 

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class LeptrisSerializer < BaseXmlSerializer
+        def name
+          'leptris'
+        end
+
+        def parse(xml_string)
+          require 'leptris'
+          require 'leptris/xml'
+          Leptris::XML.parse(xml_string)
+        end
+
+        def generate(data)
+          require 'leptris'
+          require 'leptris/xml'
+          if data.is_a?(Leptris::XML::Document) || data.is_a?(Leptris::XML::Node)
+            data.to_xml(indent: 2)
+          else
+            build_document_from_data(data).to_xml(indent: 2)
+          end
+        end
+
+        def parse_streaming(xml_string, &block)
+          require 'leptris'
+          require 'leptris/xml'
+
+          handler = StreamingHandler.new(&block)
+          parser = Leptris::XML::SAX::Parser.new(handler)
+          parser.parse_memory(xml_string)
+          handler.elements_processed
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def capabilities
+          super | Set.new(%i[xpath namespaces sax stax])
+        end
+
+        def xpath_query(document, expression)
+          require 'leptris'
+          require 'leptris/xml'
+          result = document.xpath(expression)
+          result.size
+        end
+
+        # leptris-ruby >= 1.6 exposes Leptris::XML::Pull, a StAX-style
+        # cursor (one event per #next). Declared by gem version so the
+        # check never triggers the FFI library load.
+
+
+        def version
+          return 'unknown' unless available?
+
+          require 'leptris'
+          require 'leptris/xml'
+          Leptris::VERSION
+        end
+
+        def library_require_name
+          'leptris'
+        end
+
+        # The gem's require succeeds even when the libtaurus shared library is
+        # missing -- the FFI load happens lazily at first use. Probe with a
+        # real parse so "available" means "actually usable".
+        def available?
+          return @available if defined?(@available)
+
+          @available = begin
+            require 'leptris'
+          require 'leptris/xml'
+            Leptris::XML.parse('<probe/>')
+            true
+          rescue StandardError, LoadError
+            false
+          end
+        end
+
+        private
+
+        def build_document_from_data(data, root_name = 'root')
+          document = Leptris::XML.parse('<root/>')
+          document.root.name = sanitize_element_name(root_name)
+          append_data(document.root, data)
+          document
+        end
+
+        def append_data(element, data)
+          case data
+          when Hash
+            data.each do |key, value|
+              child = element.document.create_element(sanitize_element_name(key.to_s))
+              element.add_child(child)
+              append_data(child, value)
+            end
+          when Array
+            data.each do |item|
+              child = element.document.create_element('item')
+              element.add_child(child)
+              append_data(child, item)
+            end
+          else
+            element.content = data.to_s
+          end
+        end
+
+        def sanitize_element_name(name)
+          sanitized = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+          sanitized = "element_#{sanitized}" if sanitized.empty? || sanitized =~ /\A\d/
+          sanitized
+        end
+
+        # SAX handler counting elements, mirroring the Nokogiri adapter's
+        # StreamingHandler shape (Leptris SAX delivers attrs as [name, value]
+        # pairs, same as Nokogiri::XML::SAX). Plain duck-typed class --
+        # Leptris::XML::SAX::Parser needs no base class, and subclassing it
+        # would trigger the FFI library load at file-load time.
+        class StreamingHandler
+          attr_reader :elements_processed
+
+          def initialize(&block)
+            @block = block
+            @elements_processed = 0
+            @element_stack = []
+          end
+
+          # No-op callbacks the parser invokes unconditionally (the base
+          # Leptris::XML::SAX::Document normally provides these).
+          def start_document; end
+          def end_document; end
+          def xmldecl(_version, _encoding, _standalone); end
+          def comment(_string); end
+          def processing_instruction(_name, _content); end
+          def start_prefix_mapping(_prefix, _uri); end
+          def end_prefix_mapping(_prefix); end
+          def warning(_string); end
+          def error(_message, _line = 0, _column = 0); end
+
+          def start_element(name, attrs = [])
+            @elements_processed += 1
+            @element_stack.push({ name: name, attributes: Hash[attrs], children: [], text: '' })
+          end
+
+          def end_element(_name)
+            element = @element_stack.pop
+            if @element_stack.empty?
+              @block&.call(element)
+            else
+              @element_stack.last[:children] << element
+            end
+          end
+
+          def characters(string)
+            return if string.strip.empty?
+
+            @element_stack.last[:text] += string if @element_stack.any?
+          end
+
+          def cdata_block(string)
+            @element_stack.last[:text] += string if @element_stack.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -38,6 +38,15 @@ module Serialbench
           handler.elements_processed
         end
 
+        def supports_xpath?
+          true
+        end
+
+        # The binding exposes a pull-parser cursor (XML::Reader)
+        def supports_stax?
+          true
+        end
+
         def supports_streaming?
           true
         end

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

@@ -38,6 +38,10 @@ module Serialbench
           handler.elements_processed
         end
 
+        def capabilities
+          super | Set.new(%i[xpath namespaces stax])
+        end
+
         def supports_streaming?
           true
         end

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

@@ -38,6 +38,14 @@ module Serialbench
           handler.elements_processed
         end
 
+        def supports_xpath?
+          true
+        end
+
+        def xpath_query(document, expression)
+          document.xpath(expression).size
+        end
+
         def supports_streaming?
           true
         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

@@ -36,10 +36,6 @@ module Serialbench
           Psych.dump(object)
         end
 
-        def features
-          %w[parsing generation built-in]
-        end
-
         private
 
         def require_library(library_name)

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,

data/lib/serialbench/site_generator.rb

@@ -30,6 +30,48 @@ 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
 
@@ -140,6 +182,18 @@ module Serialbench
       }
     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)
@@ -148,7 +202,7 @@ module Serialbench
 
       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}"
+        env_key = env_identity(result)
 
         # Merge this result's data into combined_results
         result_combined = build_combined_results(result, env_key)
@@ -258,7 +312,7 @@ module Serialbench
 
     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}"
+      env_key = env_identity(result)
       filename = "#{env_key}.yaml"
       filepath = File.join(data_dir, filename)