serialbench 0.1.1 → 0.1.3

data/lib/serialbench/config_manager.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'ostruct'
+require_relative 'schema_validator'
+
+module Serialbench
+  # Manages configuration loading and validation for Serialbench
+  class ConfigManager
+    class ConfigurationError < StandardError; end
+
+    SCHEMA_PATH = File.join(__dir__, '../../docs/serialbench_config_schema.yaml')
+
+    # Load and validate configuration from file
+    def self.load_and_validate(config_path)
+      new.load_and_validate(config_path)
+    end
+
+    def initialize
+      @validator = SchemaValidator.new
+    end
+
+    # Load configuration file and validate against schema
+    def load_and_validate(config_path)
+      raise ConfigurationError, "Configuration file not found: #{config_path}" unless File.exist?(config_path)
+
+      begin
+        config_data = YAML.load_file(config_path)
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid YAML syntax in #{config_path}: #{e.message}"
+      rescue StandardError => e
+        raise ConfigurationError, "Error reading configuration file #{config_path}: #{e.message}"
+      end
+
+      validate_config(config_data, config_path)
+      normalize_config(config_data)
+    end
+
+    private
+
+    # Validate configuration against schema
+    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
+      raise ConfigurationError, "Configuration schema not found: #{SCHEMA_PATH}" unless File.exist?(SCHEMA_PATH)
+
+      begin
+        YAML.load_file(SCHEMA_PATH)
+      rescue StandardError => e
+        raise ConfigurationError, "Error loading configuration schema: #{e.message}"
+      end
+    end
+
+    # Normalize and convert configuration to structured object
+    def normalize_config(config_data)
+      config = OpenStruct.new(config_data)
+
+      # Apply defaults
+      config.output_dir ||= 'benchmark-results'
+      config.benchmark_config ||= 'config/full.yml'
+      config.auto_install = true if config.auto_install.nil?
+
+      # Validate runtime-specific requirements
+      case config.runtime
+      when 'docker'
+        validate_docker_config(config)
+      when 'asdf'
+        validate_asdf_config(config)
+      else
+        raise ConfigurationError, "Unknown runtime: #{config.runtime}"
+      end
+
+      config
+    end
+
+    # Validate Docker-specific configuration
+    def validate_docker_config(config)
+      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]
+      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
+      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|
+        raise ConfigurationError, "ASDF runtime requires full version numbers (e.g., '3.2.8'), got: #{version}" unless version.match?(/^\d+\.\d+\.\d+$/)
+      end
+    end
+
+    # Basic configuration validation
+    def validate_basic_config(config_data)
+      # Check required fields
+      required_fields = %w[runtime ruby_versions output_dir benchmark_config]
+      required_fields.each do |field|
+        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(', ')}"
+      end
+
+      # Validate ruby_versions is an array
+      raise ConfigurationError, 'ruby_versions must be an array' unless config_data['ruby_versions'].is_a?(Array)
+
+      return unless config_data['ruby_versions'].empty?
+
+      raise ConfigurationError, 'ruby_versions cannot be empty'
+    end
+
+    # Check if a command is available in PATH
+    def command_available?(command)
+      system("which #{command} > /dev/null 2>&1")
+    end
+  end
+end

data/lib/serialbench/models/benchmark_config.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Serialbench
+  module Models
+    # Configuration for comprehensive benchmarks - Full testing with all data sizes
+    # Used by Docker script for complete performance analysis
+
+    # data_sizes:
+    #   - small
+    #   - medium
+    #   - large
+
+    # formats:
+    #   - xml
+    #   - json
+    #   - yaml
+    #   - toml
+
+    # iterations:
+    #   small: 20
+    #   medium: 5
+    #   large: 2
+
+    # # Enable memory profiling for comprehensive analysis
+    # memory_profiling: true
+
+    # # Standard warmup iterations
+    # warmup_iterations: 3
+
+    # # Enable streaming benchmarks where supported
+    # streaming_benchmarks: true
+
+    class BenchmarkIteration < Lutaml::Model::Serializable
+      attribute :small, :integer, default: -> { 20 }
+      attribute :medium, :integer, default: -> { 5 }
+      attribute :large, :integer, default: -> { 2 }
+
+      key_value do
+        map 'small', to: :small
+        map 'medium', to: :medium
+        map 'large', to: :large
+      end
+    end
+
+    class BenchmarkConfig < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :description, :string
+      attribute :data_sizes, :string, collection: true, values: %w[small medium large]
+      attribute :formats, :string, collection: true, values: %w[xml json yaml toml]
+      attribute :iterations, BenchmarkIteration
+      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
+
+      def self.from_file(file_path)
+        from_yaml(IO.read(file_path))
+      end
+    end
+  end
+end

data/lib/serialbench/models/benchmark_result.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Serialbench
+  module Models
+    class SerializerInformation < Lutaml::Model::Serializable
+      attribute :format, :string, values: %w[xml json yaml toml]
+      attribute :name, :string
+      attribute :version, :string
+
+      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
+      attribute :time_per_iterations, :float
+      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
+      attribute :total_allocated, :integer
+      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
+      attribute :serializers, SerializerInformation, collection: true
+      attribute :parsing, IterationPerformance, collection: true
+      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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative '../ruby_build_manager'
+
+module Serialbench
+  module Models
+    # ---
+    # name: docker-ruby-3.2
+    # kind: docker
+    # created_at: '2025-06-13T15:18:43+08:00'
+    # ruby_build_tag: "3.2.4"
+    # description: Docker environment for Ruby 3.2 benchmarks
+    # docker:
+    #   image: 'ruby:3.2-slim'
+    #   dockerfile: '../../docker/Dockerfile.ubuntu'
+
+    class DockerEnvConfig < Lutaml::Model::Serializable
+      attribute :image, :string
+      attribute :dockerfile, :string
+
+      key_value do
+        map 'image', to: :image
+        map 'dockerfile', to: :dockerfile
+      end
+    end
+
+    # ---
+    # name: ruby-324-asdf
+    # kind: asdf
+    # created_at: '2025-06-12T22:54:43+08:00'
+    # ruby_build_tag: 3.2.4
+    # description: ASDF environment
+    # asdf:
+    #   auto_install: true
+    class AsdfEnvConfig < Lutaml::Model::Serializable
+      attribute :auto_install, :boolean, default: -> { true }
+
+      key_value do
+        map 'auto_install', to: :auto_install
+      end
+    end
+
+    class EnvironmentConfig < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :kind, :string
+      attribute :created_at, :string, default: -> { Time.now.utc.iso8601 }
+      attribute :ruby_build_tag, :string
+      attribute :description, :string
+      attribute :docker, DockerEnvConfig
+      attribute :asdf, AsdfEnvConfig
+
+      key_value do
+        map 'name', to: :name
+        map 'description', to: :description
+        map 'kind', to: :kind
+        map 'created_at', to: :created_at
+        map 'ruby_build_tag', to: :ruby_build_tag
+        map 'docker', to: :docker
+        map 'asdf', to: :asdf
+      end
+
+      def to_file(file_path)
+        File.write(file_path, to_yaml)
+      end
+
+      def self.from_file(file_path)
+        from_yaml(IO.read(file_path))
+      end
+    end
+  end
+end

data/lib/serialbench/models/platform.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative '../ruby_build_manager'
+
+module Serialbench
+  module Models
+    # platform:
+    #   platform_string: docker-ruby-3.0
+    #   kind: docker
+    #   os: linux
+    #   arch: arm64
+    #   ruby_build_tag: 3.0.7
+
+    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 }
+      attribute :ruby_version, :string, default: -> { RUBY_VERSION }
+      attribute :ruby_platform, :string, default: -> { RUBY_PLATFORM }
+      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
+
+        new(
+          platform_string: platform_string,
+          kind: 'local',
+          os: os,
+          arch: arch,
+          ruby_version: version,
+          ruby_build_tag: version
+        )
+      end
+
+      def self.detect_os
+        case RbConfig::CONFIG['host_os']
+        when /darwin/i
+          'macos'
+        when /linux/i
+          'linux'
+        when /mswin|mingw|cygwin/i
+          'windows'
+        else
+          'unknown'
+        end
+      end
+
+      def self.detect_arch
+        case RbConfig::CONFIG['host_cpu']
+        when /x86_64|amd64/i
+          'x86_64'
+        when /aarch64|arm64/i
+          'arm64'
+        when /arm/i
+          'arm'
+        else
+          '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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'fileutils'
+require_relative 'platform'
+require_relative 'benchmark_result'
+require_relative 'benchmark_config'
+require_relative 'environment_config'
+
+module Serialbench
+  module Models
+    class RunMetadata < Lutaml::Model::Serializable
+      attribute :created_at, :string, default: -> { Time.now.utc.iso8601 }
+      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
+      attribute :platform, Platform
+      attribute :metadata, RunMetadata
+      attribute :environment_config, EnvironmentConfig
+      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)
+
+        # Load benchmark data
+        data_file = File.join(path, 'results.yaml')
+
+        raise ArgumentError, "No results data found in #{path}" unless File.exist?(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')
+        return [] unless Dir.exist?(base_path)
+
+        Dir.glob(File.join(base_path, '*')).select { |path| Dir.exist?(path) }.map do |path|
+          load(path)
+        rescue StandardError => e
+          warn "Failed to load run result from #{path}: #{e.message}"
+          nil
+        end.compact
+      end
+
+      def to_file(path)
+        File.write(path, to_yaml)
+      end
+    end
+  end
+end

data/lib/serialbench/models/result_set.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'time'
+require 'fileutils'
+
+module Serialbench
+  module Models
+    # ResultSet model for managing collections of benchmark results
+    class ResultSet < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :description, :string
+      attribute :created_at, :string, default: -> { Time.now.utc.iso8601 }
+      attribute :updated_at, :string, default: -> { Time.now.utc.iso8601 }
+      attribute :results, Result, collection: true, initialize_empty: true
+
+      def self.load(path)
+        raise ArgumentError, "Path does not exist: #{path}" unless Dir.exist?(path)
+
+        # Load benchmark data
+        data_file = File.join(path, 'resultset.yaml')
+
+        raise ArgumentError, "No results data found in #{path}" unless File.exist?(data_file)
+
+        from_yaml(IO.read(data_file))
+      end
+
+      def to_file(path)
+        File.write(path, to_yaml)
+      end
+
+      def save(dir)
+        FileUtils.mkdir_p(dir)
+        to_file(File.join(dir, 'resultset.yaml'))
+      end
+
+      def add_result(result_path)
+        # Assume result_path is the directory containing benchmark results and is named
+        # accordingly
+        result_name = File.basename(result_path)
+        raise ArgumentError, 'Result name cannot be empty' if result_name.empty?
+        # Validate that the result path is a directory
+        raise ArgumentError, 'Result path must be a directory' unless File.directory?(result_path)
+
+        result_file_path = File.join(result_path, 'results.yaml')
+        raise ArgumentError, "No results data found in #{result_path}" unless File.exist?(result_file_path)
+
+        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
+        end
+
+        raise ArgumentError, 'Result is already present in this resultset' if duplicates.any?
+
+        # Add the result to the resultset
+        results << result
+        self.updated_at = Time.now.utc.iso8601
+
+        result
+      end
+    end
+  end
+end