serialbench 0.1.2 → 0.2.0

data/lib/serialbench/models/result.rb

@@ -14,6 +14,13 @@ module Serialbench
       attribute :benchmark_config_path, :string
       attribute :environment_config_path, :string
       attribute :tags, :string, collection: true
+
+      key_value do
+        map 'created_at', to: :created_at
+        map 'benchmark_config_path', to: :benchmark_config_path
+        map 'environment_config_path', to: :environment_config_path
+        map 'tags', to: :tags
+      end
     end
 
     class Result < Lutaml::Model::Serializable
@@ -23,6 +30,14 @@ module Serialbench
       attribute :benchmark_config, BenchmarkConfig
       attribute :benchmark_result, BenchmarkResult
 
+      key_value do
+        map 'platform', to: :platform
+        map 'metadata', to: :metadata
+        map 'environment_config', to: :environment_config
+        map 'benchmark_config', to: :benchmark_config
+        map 'benchmark_result', to: :benchmark_result
+      end
+
       def self.load(path)
         raise ArgumentError, "Path does not exist: #{path}" unless Dir.exist?(path)
 
@@ -31,7 +46,19 @@ module Serialbench
 
         raise ArgumentError, "No results data found in #{path}" unless File.exist?(data_file)
 
-        from_yaml(IO.read(data_file))
+        yaml_content = IO.read(data_file)
+
+        # Debug: Check if yaml_content is empty or too small
+        if yaml_content.nil? || yaml_content.strip.empty?
+          raise ArgumentError, "Results file at #{data_file} is empty"
+        end
+
+        if yaml_content.bytesize < 200
+          warn "WARNING: Results file at #{data_file} is suspiciously small (#{yaml_content.bytesize} bytes)"
+          warn "Content preview: #{yaml_content[0..100]}"
+        end
+
+        from_yaml(yaml_content)
       end
 
       def self.find_all(base_path = 'results/runs')

data/lib/serialbench/models/result_set.rb

@@ -47,12 +47,20 @@ module Serialbench
 
         result = Result.load(result_path)
 
+        # Validate that the result has required fields
+        raise ArgumentError, "Result from #{result_path} is missing platform information" if result.platform.nil?
+        raise ArgumentError, "Result from #{result_path} is missing environment_config" if result.environment_config.nil?
+        raise ArgumentError, "Result from #{result_path} is missing benchmark_config" if result.benchmark_config.nil?
+
         # Check if result already exists:
         # If environment_config.created_at is identical;
         # If platform.platform_string is identical;
         # If benchmark_config.benchmark_name is identical;
 
         duplicates = results.select do |r|
+          # Skip results with nil platform (defensive check)
+          next if r.platform.nil? || result.platform.nil?
+
           r.platform.platform_string == result.platform.platform_string &&
             r.environment_config.created_at == result.environment_config.created_at &&
             r.benchmark_config.benchmark_name == result.benchmark_config.benchmark_name

data/lib/serialbench/ruby_build_manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'json'
+require 'octokit'
 require 'yaml'
 require 'fileutils'
 
@@ -34,9 +33,7 @@ module Serialbench
       def show_definition(tag)
         definitions = load_definitions_from_cache
 
-        unless definitions.include?(tag)
-          raise "Ruby-Build definition '#{tag}' not found. Available definitions: #{definitions.length}"
-        end
+        raise "Ruby-Build definition '#{tag}' not found. Available definitions: #{definitions.length}" unless definitions.include?(tag)
 
         {
           tag: tag,
@@ -66,7 +63,7 @@ module Serialbench
         variations = [
           ruby_version,
           "#{ruby_version}.0",
-          ruby_version.split('.')[0..1].join('.') + '.0'
+          "#{ruby_version.split('.')[0..1].join('.')}.0"
         ]
 
         variations.each do |variation|
@@ -101,30 +98,28 @@ module Serialbench
       private
 
       def fetch_definitions_from_github
-        uri = URI(GITHUB_API_URL)
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Get.new(uri)
-        request['Accept'] = 'application/vnd.github.v3+json'
-        request['User-Agent'] = 'Serialbench Ruby-Build Manager'
-
-        response = http.request(request)
+        # Initialize client with optional authentication
+        # Falls back to unauthenticated if GITHUB_TOKEN not set
+        client_options = {}
+        client_options[:access_token] = ENV['GITHUB_TOKEN'] if ENV['GITHUB_TOKEN']
 
-        raise "GitHub API request failed: #{response.code} #{response.message}" unless response.code == '200'
+        client = Octokit::Client.new(client_options)
 
-        data = JSON.parse(response.body)
+        contents = client.contents('rbenv/ruby-build', path: 'share/ruby-build')
 
         # Extract definition names from the file list
-        definitions = data
-                      .select { |item| item['type'] == 'file' }
-                      .map { |item| item['name'] }
+        definitions = contents
+                      .select { |item| item[:type] == 'file' && item[:name] != 'Makefile' }
+                      .map { |item| item[:name] }
                       .sort
 
         raise 'No Ruby-Build definitions found in GitHub response' if definitions.empty?
 
         definitions
+      rescue Octokit::Error => e
+        warn "Warning: Error fetching Ruby-Build definitions from GitHub: #{e.message}"
+        warn "Note: Set GITHUB_TOKEN environment variable to avoid rate limits"
+        []
       end
 
       def save_definitions_to_cache(definitions)
@@ -141,12 +136,13 @@ module Serialbench
       end
 
       def load_definitions_from_cache
-        ensure_cache_exists!
+        return [] unless cache_exists?
 
         cache_data = YAML.load_file(CACHE_FILE)
         cache_data['definitions'] || []
       rescue StandardError => e
-        raise "Failed to load Ruby-Build definitions from cache: #{e.message}"
+        warn "Warning: Failed to load Ruby-Build definitions from cache: #{e.message}"
+        []
       end
     end
   end

data/lib/serialbench/runners/asdf_runner.rb

@@ -134,7 +134,7 @@ module Serialbench
       end
 
       # Run benchmark for specific Ruby version
-      def run_benchmark(benchmark_config, benchmark_config_path, result_dir)
+      def run_benchmark(benchmark_config, _benchmark_config_path, result_dir)
         puts "🚀 Running benchmark for #{@name}..."
 
         FileUtils.mkdir_p(result_dir)

data/lib/serialbench/runners/docker_runner.rb

@@ -78,9 +78,7 @@ module Serialbench
 
       # Validate Docker is available
       def validate_docker_available
-        unless system('docker --version > /dev/null 2>&1')
-          raise DockerError, 'Docker is not installed or not available in PATH'
-        end
+        raise DockerError, 'Docker is not installed or not available in PATH' unless system('docker --version > /dev/null 2>&1')
 
         return if system('docker info > /dev/null 2>&1')
 
@@ -94,7 +92,7 @@ module Serialbench
       end
 
       # Run benchmark in container
-      def run_benchmark_in_container(benchmark_config, benchmark_config_path, result_dir)
+      def run_benchmark_in_container(_benchmark_config, benchmark_config_path, result_dir)
         puts '🏃 Running benchmark in Docker container...'
         puts "   📁 Results will be saved to: #{result_dir}"
         puts "   🐳 Using Docker image: #{docker_image_string}"

data/lib/serialbench/runners/local_runner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'base'
+require_relative '../benchmark_runner'
+require_relative '../models/result'
+require_relative '../models/platform'
+
+module Serialbench
+  module Runners
+    # Handles local benchmark execution using the current Ruby environment
+    class LocalRunner < Base
+      def prepare
+        # For local environments, no preparation is needed
+        # The current Ruby environment is already set up
+        puts "✅ Local environment ready (using current Ruby: #{RUBY_VERSION})"
+      end
+
+      def run_benchmark(benchmark_config, benchmark_config_path, result_dir)
+        puts "🏠 Running benchmark locally with Ruby #{RUBY_VERSION}..."
+        puts "   📁 Results will be saved to: #{result_dir}"
+
+        FileUtils.mkdir_p(result_dir)
+
+        # Run the benchmark
+        runner = Serialbench::BenchmarkRunner.new(
+          environment_config: @environment_config,
+          benchmark_config: benchmark_config
+        )
+
+        results = runner.run_all_benchmarks
+
+        # Get platform information with correct Ruby version from environment config
+        platform = Serialbench::Models::Platform.current_local(
+          ruby_version: @environment_config.ruby_build_tag
+        )
+
+        # Create metadata
+        metadata = Models::RunMetadata.new(
+          benchmark_config_path: benchmark_config_path,
+          environment_config_path: @environment_config_path,
+          tags: [
+            'local',
+            platform.os,
+            platform.arch,
+            "ruby-#{@environment_config.ruby_build_tag}"
+          ]
+        )
+
+        # Save results
+        results_model = Models::Result.new(
+          platform: platform,
+          metadata: metadata,
+          environment_config: @environment_config,
+          benchmark_config: benchmark_config,
+          benchmark_result: results
+        )
+
+        # Restore YAML to use Psych for output, otherwise lutaml-model's to_yaml
+        # will have no output (Syck gem overrides YAML constant)
+        Object.const_set(:YAML, Psych)
+
+        results_file = File.join(result_dir, 'results.yaml')
+        results_model.to_file(results_file)
+
+        puts "✅ Benchmark completed successfully"
+        puts "   📊 Results saved to: #{results_file}"
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/base_serializer.rb

@@ -25,7 +25,7 @@ module Serialbench
         raise NotImplementedError, 'Subclasses must implement #generate'
       end
 
-      def stream_parse(data, &block)
+      def stream_parse(data)
         # Default implementation falls back to regular parsing
         # Override in subclasses that support streaming
         result = parse(data)

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

@@ -27,15 +27,11 @@ module Serialbench
           RapidJSON.parse(json_string)
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           require 'rapidjson'
           RapidJSON.dump(object)
         end
 
-        def features
-          %w[parsing generation high-performance c-extension]
-        end
-
         private
 
         def require_library(library_name)

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

@@ -59,8 +59,6 @@ module Serialbench
           raise NotImplementedError, 'Subclasses must implement #library_require_name'
         end
 
-        public
-
         # Check if the TOML library is available
         def available?
           return @available if defined?(@available)

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

@@ -27,7 +27,7 @@ module Serialbench
           TomlRB.parse(toml_string)
         end
 
-        def generate(object, options = {})
+        def generate(object, _options = {})
           require 'toml-rb'
           TomlRB.dump(object)
         end

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

@@ -24,7 +24,7 @@ module Serialbench
           # TOML doesn't typically support streaming parsing
           # Parse the entire document and yield it
           result = parse(toml_string)
-          block&.call(result) if block
+          block&.call(result)
           1 # Return 1 document processed
         end
 

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

@@ -29,10 +29,15 @@ module Serialbench
             xpath: supports_xpath?,
             namespaces: supports_namespaces?,
             validation: supports_validation?,
-            streaming: supports_streaming?
+            streaming: supports_streaming?,
+            stax: supports_stax?
           }
         end
 
+        def supports_stax?
+          false
+        end
+
         def supports_generation?
           true
         end

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

@@ -0,0 +1,167 @@
+# 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'
+          Leptris::XML.parse(xml_string)
+        end
+
+        def generate(data)
+          require 'leptris'
+          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'
+
+          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 supports_xpath?
+          true
+        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 supports_stax?
+          spec = Gem.loaded_specs['leptris'] || Gem::Specification.find_by_name('leptris')
+          !spec.nil? && spec.version >= Gem::Version.new('1.6.0')
+        rescue Gem::LoadError
+          false
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'leptris'
+          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'
+            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
@@ -58,26 +67,22 @@ module Serialbench
         def build_xml_from_data(data, name = 'root')
           require 'libxml'
 
+          element = LibXML::XML::Node.new(name.to_s)
           case data
           when Hash
-            element = LibXML::XML::Node.new(name.to_s)
             data.each do |key, value|
               child = build_xml_from_data(value, key.to_s)
               element << child
             end
-            element
           when Array
-            element = LibXML::XML::Node.new(name.to_s)
             data.each_with_index do |item, index|
               child = build_xml_from_data(item, "item_#{index}")
               element << child
             end
-            element
           else
-            element = LibXML::XML::Node.new(name.to_s)
             element.content = data.to_s
-            element
           end
+          element
         end
 
         # SAX handler for streaming
@@ -100,10 +105,10 @@ module Serialbench
             @element_stack.push(@current_element)
           end
 
-          def on_end_element(element)
+          def on_end_element(_element)
             element_data = @element_stack.pop
             if @element_stack.empty?
-              @block&.call(element_data) if @block
+              @block&.call(element_data)
             else
               @element_stack.last[:children] << element_data
             end

data/lib/serialbench/serializers/xml/nokogiri_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
@@ -109,10 +118,10 @@ module Serialbench
             @element_stack.push(@current_element)
           end
 
-          def end_element(name)
+          def end_element(_name)
             element = @element_stack.pop
             if @element_stack.empty?
-              @block&.call(element) if @block
+              @block&.call(element)
             else
               @element_stack.last[:children] << element
             end

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

@@ -38,6 +38,10 @@ module Serialbench
           handler.elements_processed
         end
 
+        def supports_xpath?
+          true
+        end
+
         def supports_streaming?
           true
         end
@@ -58,27 +62,23 @@ module Serialbench
         def build_xml_from_data(data, name = 'root')
           require 'oga'
 
+          element = Oga::XML::Element.new(name: name)
           case data
           when Hash
-            element = Oga::XML::Element.new(name: name)
             data.each do |key, value|
               child = build_xml_from_data(value, key.to_s)
               element.children << child
             end
-            element
           when Array
-            element = Oga::XML::Element.new(name: name)
             data.each_with_index do |item, index|
               child = build_xml_from_data(item, "item_#{index}")
               element.children << child
             end
-            element
           else
-            element = Oga::XML::Element.new(name: name)
             text_node = Oga::XML::Text.new(text: data.to_s)
             element.children << text_node
-            element
           end
+          element
         end
 
         # SAX handler for streaming
@@ -108,10 +108,10 @@ module Serialbench
             @element_stack.last[:text] += text if @element_stack.any?
           end
 
-          def after_element(namespace, name)
+          def after_element(_namespace, _name)
             element = @element_stack.pop
             if @element_stack.empty?
-              @block&.call(element) if @block
+              @block&.call(element)
             else
               @element_stack.last[:children] << element
             end

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

@@ -61,10 +61,10 @@ module Serialbench
             @element_stack.push(@current_element)
           end
 
-          def end_element(name)
+          def end_element(_name)
             element = @element_stack.pop
             if @element_stack.empty?
-              @block&.call(element) if @block
+              @block&.call(element)
             else
               @element_stack.last[:children] << element
             end