serialbench 0.1.2 → 0.1.3

data/lib/serialbench/cli/validate_cli.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base_cli'
+require_relative '../yaml_validator'
+
+module Serialbench
+  module Cli
+    # CLI for validating YAML files against schemas
+    class ValidateCli < BaseCli
+      desc 'result RESULT_FILE', 'Validate a benchmark result YAML file'
+      long_desc <<~DESC
+        Validate a benchmark result YAML file against its schema.
+
+        RESULT_FILE should be the path to a results.yaml file
+
+        Examples:
+          serialbench validate result results/runs/my-run/results.yaml
+          serialbench validate result test-artifacts/benchmark-results-ubuntu-latest-ruby-3.4/results.yaml
+      DESC
+      def result(file_path)
+        validate_file(file_path, 'result', 'Result')
+      end
+
+      desc 'config BENCHMARK_CONFIG', 'Validate a benchmark configuration file'
+      long_desc <<~DESC
+        Validate a benchmark configuration file against its schema.
+
+        BENCHMARK_CONFIG should be the path to a benchmark config YAML file
+
+        Examples:
+          serialbench validate config config/benchmarks/short.yml
+          serialbench validate config config/benchmarks/full.yml
+      DESC
+      def config(file_path)
+        validate_file(file_path, 'benchmark_config', 'Benchmark config')
+      end
+
+      desc 'environment ENV_CONFIG', 'Validate an environment configuration file'
+      long_desc <<~DESC
+        Validate an environment configuration file against its schema.
+
+        ENV_CONFIG should be the path to an environment config YAML file
+
+        Examples:
+          serialbench validate environment config/environments/local-dev.yml
+          serialbench validate environment config/environments/docker-ruby-3.4.yml
+      DESC
+      def environment(file_path)
+        validate_file(file_path, 'environment_config', 'Environment config')
+      end
+
+      desc 'resultset RESULTSET_FILE', 'Validate a resultset YAML file'
+      long_desc <<~DESC
+        Validate a resultset YAML file against its schema.
+
+        RESULTSET_FILE should be the path to a resultset.yaml file
+
+        Examples:
+          serialbench validate resultset results/sets/weekly-benchmark/resultset.yaml
+          serialbench validate resultset results/sets/comparison/resultset.yaml
+      DESC
+      def resultset(file_path)
+        validate_file(file_path, 'resultset', 'Resultset')
+      end
+
+      private
+
+      def validate_file(file_path, schema_name, friendly_name)
+        unless File.exist?(file_path)
+          say "❌ File not found: #{file_path}", :red
+          exit 1
+        end
+
+        say "📝 Validating #{friendly_name}: #{file_path}", :cyan
+
+        if Serialbench::YamlValidator.validate(file_path, schema_name)
+          say "✅ #{friendly_name} is valid", :green
+        else
+          say "❌ #{friendly_name} validation failed", :red
+          exit 1
+        end
+      rescue StandardError => e
+        say "❌ Error: #{e.message}", :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/serialbench/cli.rb

@@ -6,6 +6,7 @@ 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'
 
 module Serialbench
   # Main CLI entry point for the new object-oriented command structure
@@ -22,6 +23,9 @@ module Serialbench
     desc 'ruby_build SUBCOMMAND', 'Manage Ruby-Build definitions for validation'
     subcommand 'ruby_build', Serialbench::Cli::RubyBuildCli
 
+    desc 'validate SUBCOMMAND', 'Validate YAML files against schemas'
+    subcommand 'validate', Serialbench::Cli::ValidateCli
+
     desc 'version', 'Show Serialbench version'
     def self.version
       puts "Serialbench version #{Serialbench::VERSION}"
@@ -73,14 +77,14 @@ module Serialbench
     end
 
     # Handle unknown commands gracefully
-    def method_missing(method_name, *args)
+    def method_missing(method_name, *_args)
       puts "Unknown command: #{method_name}"
       puts ''
       help
       exit 1
     end
 
-    def respond_to_missing?(method_name, include_private = false)
+    def respond_to_missing?(_method_name, _include_private = false)
       false
     end
   end

data/lib/serialbench/config_manager.rb

@@ -39,16 +39,14 @@ module Serialbench
     private
 
     # Validate configuration against schema
-    def validate_config(config_data, config_path)
+    def validate_config(config_data, _config_path)
       # For now, perform basic validation since we don't have a specific config schema validator
       validate_basic_config(config_data)
     end
 
     # Load the configuration schema
     def load_schema
-      unless File.exist?(SCHEMA_PATH)
-        raise ConfigurationError, "Configuration schema not found: #{SCHEMA_PATH}"
-      end
+      raise ConfigurationError, "Configuration schema not found: #{SCHEMA_PATH}" unless File.exist?(SCHEMA_PATH)
 
       begin
         YAML.load_file(SCHEMA_PATH)
@@ -81,28 +79,22 @@ module Serialbench
 
     # Validate Docker-specific configuration
     def validate_docker_config(config)
-      unless config.image_variants && !config.image_variants.empty?
-        raise ConfigurationError, "Docker runtime requires 'image_variants' to be specified"
-      end
+      raise ConfigurationError, "Docker runtime requires 'image_variants' to be specified" unless config.image_variants && !config.image_variants.empty?
 
       invalid_variants = config.image_variants - %w[slim alpine]
-      unless invalid_variants.empty?
-        raise ConfigurationError, "Invalid image variants: #{invalid_variants.join(', ')}. Valid variants: slim, alpine"
-      end
+      return if invalid_variants.empty?
+
+      raise ConfigurationError, "Invalid image variants: #{invalid_variants.join(', ')}. Valid variants: slim, alpine"
     end
 
     # Validate ASDF-specific configuration
     def validate_asdf_config(config)
       # Check if ASDF is available
-      unless command_available?('asdf')
-        raise ConfigurationError, "ASDF is not installed or not in PATH. Please install ASDF to use asdf runtime."
-      end
+      raise ConfigurationError, 'ASDF is not installed or not in PATH. Please install ASDF to use asdf runtime.' unless command_available?('asdf')
 
       # Validate Ruby version format for ASDF (should include patch version)
       config.ruby_versions.each do |version|
-        unless version.match?(/^\d+\.\d+\.\d+$/)
-          raise ConfigurationError, "ASDF runtime requires full version numbers (e.g., '3.2.8'), got: #{version}"
-        end
+        raise ConfigurationError, "ASDF runtime requires full version numbers (e.g., '3.2.8'), got: #{version}" unless version.match?(/^\d+\.\d+\.\d+$/)
       end
     end
 
@@ -111,25 +103,22 @@ module Serialbench
       # Check required fields
       required_fields = %w[runtime ruby_versions output_dir benchmark_config]
       required_fields.each do |field|
-        unless config_data.key?(field)
-          raise ConfigurationError, "Missing required field: #{field}"
-        end
+        raise ConfigurationError, "Missing required field: #{field}" unless config_data.key?(field)
       end
 
       # Validate runtime
       valid_runtimes = %w[docker asdf]
       unless valid_runtimes.include?(config_data['runtime'])
-        raise ConfigurationError, "Invalid runtime: #{config_data['runtime']}. Valid runtimes: #{valid_runtimes.join(', ')}"
+        raise ConfigurationError,
+              "Invalid runtime: #{config_data['runtime']}. Valid runtimes: #{valid_runtimes.join(', ')}"
       end
 
       # Validate ruby_versions is an array
-      unless config_data['ruby_versions'].is_a?(Array)
-        raise ConfigurationError, "ruby_versions must be an array"
-      end
+      raise ConfigurationError, 'ruby_versions must be an array' unless config_data['ruby_versions'].is_a?(Array)
 
-      if config_data['ruby_versions'].empty?
-        raise ConfigurationError, "ruby_versions cannot be empty"
-      end
+      return unless config_data['ruby_versions'].empty?
+
+      raise ConfigurationError, 'ruby_versions cannot be empty'
     end
 
     # Check if a command is available in PATH

data/lib/serialbench/models/benchmark_config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lutaml/model'
 
 module Serialbench
@@ -51,6 +53,16 @@ module Serialbench
       attribute :warmup, :integer, default: -> { 1 }
       attribute :operations, :string, collection: true, values: %w[parse generate memory streaming]
 
+      key_value do
+        map 'name', to: :name
+        map 'description', to: :description
+        map 'data_sizes', to: :data_sizes
+        map 'formats', to: :formats
+        map 'iterations', to: :iterations
+        map 'warmup', to: :warmup
+        map 'operations', to: :operations
+      end
+
       def to_file(file_path)
         File.write(file_path, to_yaml)
       end

data/lib/serialbench/models/benchmark_result.rb

@@ -8,16 +8,24 @@ module Serialbench
       attribute :format, :string, values: %w[xml json yaml toml]
       attribute :name, :string
       attribute :version, :string
-    end
 
-    class SerializerInformationCollection < Lutaml::Model::Collection
-      instances :items, SerializerInformation
+      key_value do
+        map 'format', to: :format
+        map 'name', to: :name
+        map 'version', to: :version
+      end
     end
 
     class AdapterPerformance < Lutaml::Model::Serializable
       attribute :adapter, :string
       attribute :format, :string, values: %w[xml json yaml toml]
       attribute :data_size, :string, values: %w[small medium large]
+
+      key_value do
+        map 'adapter', to: :adapter
+        map 'format', to: :format
+        map 'data_size', to: :data_size
+      end
     end
 
     class IterationPerformance < AdapterPerformance
@@ -25,6 +33,16 @@ module Serialbench
       attribute :time_per_iteration, :float
       attribute :iterations_per_second, :float
       attribute :iterations_count, :integer
+
+      key_value do
+        map 'adapter', to: :adapter
+        map 'format', to: :format
+        map 'data_size', to: :data_size
+        map 'time_per_iterations', to: :time_per_iterations
+        map 'time_per_iteration', to: :time_per_iteration
+        map 'iterations_per_second', to: :iterations_per_second
+        map 'iterations_count', to: :iterations_count
+      end
     end
 
     class MemoryPerformance < AdapterPerformance
@@ -32,6 +50,16 @@ module Serialbench
       attribute :total_retained, :integer
       attribute :allocated_memory, :integer
       attribute :retained_memory, :integer
+
+      key_value do
+        map 'adapter', to: :adapter
+        map 'format', to: :format
+        map 'data_size', to: :data_size
+        map 'total_allocated', to: :total_allocated
+        map 'total_retained', to: :total_retained
+        map 'allocated_memory', to: :allocated_memory
+        map 'retained_memory', to: :retained_memory
+      end
     end
 
     class BenchmarkResult < Lutaml::Model::Serializable
@@ -40,6 +68,14 @@ module Serialbench
       attribute :generation, IterationPerformance, collection: true
       attribute :memory, MemoryPerformance, collection: true
       attribute :streaming, IterationPerformance, collection: true
+
+      key_value do
+        map 'serializers', to: :serializers
+        map 'parsing', to: :parsing
+        map 'generation', to: :generation
+        map 'memory', to: :memory
+        map 'streaming', to: :streaming
+      end
     end
   end
 end

data/lib/serialbench/models/environment_config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lutaml/model'
 require_relative '../ruby_build_manager'
 
@@ -43,8 +45,7 @@ module Serialbench
       attribute :name, :string
       attribute :kind, :string
       attribute :created_at, :string, default: -> { Time.now.utc.iso8601 }
-      attribute :ruby_build_tag, :string, values:
-        RubyBuildManager.list_definitions
+      attribute :ruby_build_tag, :string
       attribute :description, :string
       attribute :docker, DockerEnvConfig
       attribute :asdf, AsdfEnvConfig

data/lib/serialbench/models/platform.rb

@@ -19,13 +19,39 @@ module Serialbench
       attribute :arch, :string, default: -> { detect_arch }
       attribute :ruby_version, :string, default: -> { RUBY_VERSION }
       attribute :ruby_platform, :string, default: -> { RUBY_PLATFORM }
-      attribute :ruby_build_tag, :string, values: RubyBuildManager.list_definitions
+      attribute :ruby_build_tag, :string
+
+      key_value do
+        map 'platform_string', to: :platform_string
+        map 'kind', to: :kind
+        map 'os', to: :os
+        map 'arch', to: :arch
+        map 'ruby_version', to: :ruby_version
+        map 'ruby_platform', to: :ruby_platform
+        map 'ruby_build_tag', to: :ruby_build_tag
+      end
+
+      def self.current_local(ruby_version: nil)
+        version = ruby_version || RUBY_VERSION
+
+        # Check for GitHub Actions runner platform
+        github_platform = ENV['GITHUB_RUNNER_PLATFORM']
+        if github_platform
+          os, arch = parse_github_platform(github_platform)
+          platform_string = "#{github_platform}-ruby-#{version}"
+        else
+          os = detect_os
+          arch = detect_arch
+          platform_string = "local-#{version}"
+        end
 
-      def self.current_local
         new(
-          platform_string: "local-#{RUBY_VERSION}",
+          platform_string: platform_string,
           kind: 'local',
-          ruby_build_tag: RUBY_VERSION
+          os: os,
+          arch: arch,
+          ruby_version: version,
+          ruby_build_tag: version
         )
       end
 
@@ -54,6 +80,32 @@ module Serialbench
           'unknown'
         end
       end
+
+      def self.parse_github_platform(platform_name)
+        # Parse GitHub Actions runner platform names
+        # Examples: ubuntu-24.04, ubuntu-24.04-arm, macos-13, macos-15-intel,
+        #           macos-14, macos-15, macos-26, windows-2022, windows-2025, windows-11-arm
+
+        case platform_name
+        when /^ubuntu.*-arm$/
+          ['linux', 'arm64']
+        when /^ubuntu/
+          ['linux', 'x86_64']
+        when /^macos-.*-intel$/
+          ['macos', 'x86_64']
+        when /^macos-(13)$/
+          ['macos', 'x86_64']
+        when /^macos-(14|15|26)$/
+          ['macos', 'arm64']
+        when /^windows.*-arm$/
+          ['windows', 'arm64']
+        when /^windows/
+          ['windows', 'x86_64']
+        else
+          # Fallback to automatic detection
+          [detect_os, detect_arch]
+        end
+      end
     end
   end
 end

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)