serialbench 0.2.0 → 0.4.0

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)
@@ -148,313 +145,28 @@ module Serialbench
 
       case type_name
       when 'generation'
-        serializers.select(&:supports_generation?)
+        serializers.select { |s| s.supports?(:generate) }
       when 'streaming'
-        serializers.select(&:supports_streaming?)
+        serializers.select { |s| s.supports?(:sax) || s.supports?(:streaming) }
+      when 'xpath'
+        serializers.select { |s| s.supports?(:xpath) }
       else
         serializers
       end
     end
 
     def get_iterations_for_size(size)
-      @benchmark_config.iterations.send(size.to_s)
-    end
-
-    def load_test_data
-      # Determine which data sizes to load based on configuration
-      data_sizes = @benchmark_config.data_sizes
-
-      # Initialize test data structure
-      @test_data = {}
-      data_sizes.each { |size| @test_data[size] = {} }
-
-      # Generate data for each format and size
-      @benchmark_config.formats.each do |format|
-        data_sizes.each do |size|
-          @test_data[size][format] = generate_test_data(format, size)
-        end
-      end
-
-      # Try to load real test files if they exist
-      data_sizes.each do |size|
-        @benchmark_config.formats.each do |format|
-          file_path = "test_data/#{size}.#{format}"
-          @test_data[size][format] = File.read(file_path) if File.exist?(file_path)
-        end
+      iterations = @benchmark_config.iterations
+      case size.to_s
+      when 'small' then iterations.small
+      when 'medium' then iterations.medium
+      when 'large' then iterations.large
+      else raise ArgumentError, "no iteration count configured for #{size}"
       end
     end
 
-    def generate_test_data(format, size)
-      method_name = "generate_#{size}_#{format}"
-      send(method_name)
-    end
-
-    # Shared data structure generators
-    def small_test_data_structure
-      {
-        config: {
-          database: {
-            host: 'localhost',
-            port: 5432,
-            name: 'myapp',
-            user: 'admin',
-            password: 'secret'
-          },
-          cache: {
-            enabled: true,
-            ttl: 3600
-          }
-        }
-      }
-    end
-
-    def medium_test_data_structure
-      {
-        users: (1..1000).map do |i|
-          {
-            id: i,
-            name: "User #{i}",
-            email: "user#{i}@example.com",
-            created_at: "2023-01-#{(i % 28) + 1}T10:00:00Z",
-            profile: {
-              age: 20 + (i % 50),
-              city: "City #{i % 100}",
-              preferences: {
-                theme: i.even? ? 'dark' : 'light',
-                notifications: (i % 3).zero?
-              }
-            }
-          }
-        end
-      }
-    end
-
-    def large_test_data_structure
-      {
-        dataset: {
-          header: {
-            created: '2023-01-01T00:00:00Z',
-            count: 10_000,
-            format: 'data'
-          },
-          records: (1..10_000).map do |i|
-            {
-              id: i,
-              timestamp: "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z",
-              data: {
-                field1: "Value #{i}",
-                field2: i * 2,
-                field3: (i % 100).zero? ? 'special' : 'normal',
-                nested: [
-                  "Item #{i}-1",
-                  "Item #{i}-2",
-                  "Item #{i}-3"
-                ]
-              },
-              metadata: {
-                source: 'generator',
-                version: '1.0',
-                checksum: i.to_s(16)
-              }
-            }
-          end
-        }
-      }
-    end
-
-    # XML test data generators
-    def generate_small_xml
-      data = small_test_data_structure
-      <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <config>
-          <database>
-            <host>#{data[:config][:database][:host]}</host>
-            <port>#{data[:config][:database][:port]}</port>
-            <name>#{data[:config][:database][:name]}</name>
-            <user>#{data[:config][:database][:user]}</user>
-            <password>#{data[:config][:database][:password]}</password>
-          </database>
-          <cache>
-            <enabled>#{data[:config][:cache][:enabled]}</enabled>
-            <ttl>#{data[:config][:cache][:ttl]}</ttl>
-          </cache>
-        </config>
-      XML
-    end
-
-    def generate_medium_xml
-      data = medium_test_data_structure
-      users = data[:users].map do |user|
-        <<~USER
-          <user id="#{user[:id]}">
-            <name>#{user[:name]}</name>
-            <email>#{user[:email]}</email>
-            <created_at>#{user[:created_at]}</created_at>
-            <profile>
-              <age>#{user[:profile][:age]}</age>
-              <city>#{user[:profile][:city]}</city>
-              <preferences>
-                <theme>#{user[:profile][:preferences][:theme]}</theme>
-                <notifications>#{user[:profile][:preferences][:notifications]}</notifications>
-              </preferences>
-            </profile>
-          </user>
-        USER
-      end.join
-
-      <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <users>
-          #{users}
-        </users>
-      XML
-    end
-
-    def generate_large_xml
-      data = large_test_data_structure
-      records = data[:dataset][:records].map do |record|
-        nested_items = record[:data][:nested].map { |item| "    <item>#{item}</item>" }.join("\n")
-        <<~RECORD
-            <record id="#{record[:id]}">
-              <timestamp>#{record[:timestamp]}</timestamp>
-              <data>
-                <field1>#{record[:data][:field1]}</field1>
-                <field2>#{record[:data][:field2]}</field2>
-                <field3>#{record[:data][:field3]}</field3>
-                <nested>
-          #{nested_items}
-                </nested>
-              </data>
-              <metadata>
-                <source>#{record[:metadata][:source]}</source>
-                <version>#{record[:metadata][:version]}</version>
-                <checksum>#{record[:metadata][:checksum]}</checksum>
-              </metadata>
-            </record>
-        RECORD
-      end.join
-
-      <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <dataset>
-          <header>
-            <created>#{data[:dataset][:header][:created]}</created>
-            <count>#{data[:dataset][:header][:count]}</count>
-            <format>xml</format>
-          </header>
-          <records>
-            #{records}
-          </records>
-        </dataset>
-      XML
-    end
-
-    # JSON test data generators
-    def generate_small_json
-      JSON.generate(small_test_data_structure)
-    end
-
-    def generate_medium_json
-      JSON.generate(medium_test_data_structure)
-    end
-
-    def generate_large_json
-      data = large_test_data_structure
-      data[:dataset][:header][:format] = 'json'
-      JSON.generate(data)
-    end
-
-    # YAML test data generators
-    def generate_small_yaml
-      small_test_data_structure.to_yaml
-    end
-
-    def generate_medium_yaml
-      medium_test_data_structure.to_yaml
-    end
-
-    def generate_large_yaml
-      data = large_test_data_structure
-      data[:dataset][:header][:format] = 'yaml'
-      data.to_yaml
-    end
-
-    # TOML test data generators
-    def generate_small_toml
-      data = small_test_data_structure
-      <<~TOML
-        [config]
-
-        [config.database]
-        host = "#{data[:config][:database][:host]}"
-        port = #{data[:config][:database][:port]}
-        name = "#{data[:config][:database][:name]}"
-        user = "#{data[:config][:database][:user]}"
-        password = "#{data[:config][:database][:password]}"
-
-        [config.cache]
-        enabled = #{data[:config][:cache][:enabled]}
-        ttl = #{data[:config][:cache][:ttl]}
-      TOML
-    end
-
-    def generate_medium_toml
-      data = medium_test_data_structure
-      # Use smaller dataset for TOML due to verbosity
-      users = data[:users].first(100)
-      users.map do |user|
-        <<~USER
-          [[users]]
-          id = #{user[:id]}
-          name = "#{user[:name]}"
-          email = "#{user[:email]}"
-          created_at = "#{user[:created_at]}"
-
-          [users.profile]
-          age = #{user[:profile][:age]}
-          city = "#{user[:profile][:city]}"
-
-          [users.profile.preferences]
-          theme = "#{user[:profile][:preferences][:theme]}"
-          notifications = #{user[:profile][:preferences][:notifications]}
-        USER
-      end.join("\n")
-    end
-
-    def generate_large_toml
-      data = large_test_data_structure
-      # Use smaller dataset for TOML due to verbosity
-      records = data[:dataset][:records].first(1000)
-      records_toml = records.map do |record|
-        <<~RECORD
-          [[dataset.records]]
-          id = #{record[:id]}
-          timestamp = "#{record[:timestamp]}"
-
-          [dataset.records.data]
-          field1 = "#{record[:data][:field1]}"
-          field2 = #{record[:data][:field2]}
-          field3 = "#{record[:data][:field3]}"
-          nested = #{record[:data][:nested].inspect}
-
-          [dataset.records.metadata]
-          source = "#{record[:metadata][:source]}"
-          version = "#{record[:metadata][:version]}"
-          checksum = "#{record[:metadata][:checksum]}"
-        RECORD
-      end.join("\n")
-
-      <<~TOML
-        [dataset]
-
-        [dataset.header]
-        created = "#{data[:dataset][:header][:created]}"
-        count = #{records.length}
-        format = "toml"
-
-        #{records_toml}
-      TOML
+    def load_test_data
+      @test_data = TestData.load(@benchmark_config)
     end
   end
 end

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.rb

@@ -4,7 +4,6 @@ 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'
 
@@ -17,9 +16,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 +41,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
@@ -62,13 +57,6 @@ module Serialbench
             serialbench benchmark create my-benchmark
             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/result_store.rb

@@ -8,7 +8,6 @@ module Serialbench
     class ResultStore
       DEFAULT_BASE_PATH = 'results'
       RUNS_PATH = 'runs'
-      SETS_PATH = 'sets'
 
       attr_reader :base_path
 
@@ -34,27 +33,6 @@ module Serialbench
         limit ? runs.first(limit) : runs
       end
 
-      # Run set management
-      def sets_path
-        File.join(@base_path, SETS_PATH)
-      end
-
-      def find_resultsets(tags: nil, limit: nil)
-        resultsets = ResultSet.find_all(sets_path)
-
-        resultsets = resultsets.select { |resultset| (Array(tags) - resultset.tags).empty? } if tags
-
-        limit ? resultsets.first(limit) : resultsets
-      end
-
-      # Convenience methods
-      def create_resultset(name, run_platform_strings, metadata: {})
-        run_paths = run_platform_strings.map { |ps| File.join(runs_path, ps) }
-        resultset = ResultSet.create(name, run_paths, metadata: metadata)
-        save_resultset(resultset)
-        resultset
-      end
-
       # Validation
       def validate_structure
         errors = []
@@ -62,7 +40,6 @@ module Serialbench
         # Check base structure
         errors << "Base path does not exist: #{@base_path}" unless Dir.exist?(@base_path)
         errors << "Runs directory does not exist: #{runs_path}" unless Dir.exist?(runs_path)
-        errors << "Sets directory does not exist: #{sets_path}" unless Dir.exist?(sets_path)
 
         # Validate individual runs
         if Dir.exist?(runs_path)
@@ -78,20 +55,6 @@ module Serialbench
           end
         end
 
-        # Validate result sets
-        if Dir.exist?(sets_path)
-          Dir.glob(File.join(sets_path, '*')).each do |set_path|
-            next unless Dir.exist?(set_path)
-
-            begin
-              resultset = ResultSet.load(set_path)
-              resultset.validate!
-            rescue StandardError => e
-              errors << "Invalid result set at #{set_path}: #{e.message}"
-            end
-          end
-        end
-
         errors
       end
 
@@ -101,7 +64,6 @@ module Serialbench
 
       def ensure_results_directory
         FileUtils.mkdir_p(runs_path) unless Dir.exist?(runs_path)
-        FileUtils.mkdir_p(sets_path) unless Dir.exist?(sets_path)
       end
     end
   end

data/lib/serialbench/models.rb

@@ -6,7 +6,6 @@ require_relative 'models/result'
 require_relative 'models/result_store'
 require_relative 'models/benchmark_config'
 require_relative 'models/environment_config'
-require_relative 'models/result_set'
 
 module Serialbench
   module Models
@@ -46,9 +45,5 @@ module Serialbench
     def self.create_run(platform_string, benchmark_data, metadata: {})
       Result.create(platform_string, benchmark_data, metadata: metadata)
     end
-
-    def self.create_resultset(name, run_paths_or_objects, metadata: {})
-      ResultSet.create(name, run_paths_or_objects, metadata: metadata)
-    end
   end
 end

data/lib/serialbench/serializers/base_serializer.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 # frozen_string_literal: true
 
 require 'singleton'
@@ -33,9 +35,15 @@ module Serialbench
         result
       end
 
-      def supports_streaming?
-        # Override in subclasses that support streaming
-        false
+      # 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 require_library(library_name)

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

@@ -19,32 +19,20 @@ module Serialbench
           generate(object, options)
         end
 
+        def capabilities
+          super | Set.new(%i[pretty_print])
+        end
+
         # JSON-specific features
         def features
           {
-            pretty_print: supports_pretty_print?,
-            streaming: supports_streaming?,
-            symbol_keys: supports_symbol_keys?,
-            custom_types: supports_custom_types?
+            pretty_print: supports?(:pretty_print),
+            streaming: supports?(:sax) || supports?(:streaming),
+            symbol_keys: supports?(:symbol_keys),
+            custom_types: supports?(:custom_types)
           }
         end
 
-        def supports_generation?
-          true
-        end
-
-        def supports_pretty_print?
-          true
-        end
-
-        def supports_symbol_keys?
-          false
-        end
-
-        def supports_custom_types?
-          false
-        end
-
         # Subclasses should override this to specify their library name
         def library_require_name
           raise NotImplementedError, 'Subclasses must implement #library_require_name'

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

@@ -34,22 +34,6 @@ module Serialbench
             JSON.generate(object)
           end
         end
-
-        def supports_streaming?
-          false
-        end
-
-        def supports_pretty_print?
-          true
-        end
-
-        def supports_symbol_keys?
-          false
-        end
-
-        def supports_custom_types?
-          false
-        end
       end
     end
   end

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

@@ -46,23 +46,8 @@ module Serialbench
           super
         end
 
-        def supports_streaming?
-          require 'oj'
-          Oj.respond_to?(:saj_parse)
-        rescue LoadError
-          false
-        end
-
-        def supports_pretty_print?
-          true
-        end
-
-        def supports_symbol_keys?
-          true
-        end
-
-        def supports_custom_types?
-          true
+        def capabilities
+          super | Set.new(%i[symbol_keys custom_types sax])
         end
       end
 

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

@@ -44,8 +44,8 @@ module Serialbench
           end
         end
 
-        def supports_streaming?
-          true
+        def capabilities
+          super | Set.new(%i[sax])
         end
 
         def version