serialbench 0.1.1 → 0.1.2

data/lib/serialbench/config_manager.rb

@@ -0,0 +1,140 @@
+# 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
+      unless File.exist?(SCHEMA_PATH)
+        raise ConfigurationError, "Configuration schema not found: #{SCHEMA_PATH}"
+      end
+
+      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)
+      unless config.image_variants && !config.image_variants.empty?
+        raise ConfigurationError, "Docker runtime requires 'image_variants' to be specified"
+      end
+
+      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
+    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
+
+      # 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
+      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|
+        unless config_data.key?(field)
+          raise ConfigurationError, "Missing required field: #{field}"
+        end
+      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
+      unless config_data['ruby_versions'].is_a?(Array)
+        raise ConfigurationError, "ruby_versions must be an array"
+      end
+
+      if config_data['ruby_versions'].empty?
+        raise ConfigurationError, "ruby_versions cannot be empty"
+      end
+    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,63 @@
+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]
+
+      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,45 @@
+# 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
+    end
+
+    class SerializerInformationCollection < Lutaml::Model::Collection
+      instances :items, SerializerInformation
+    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]
+    end
+
+    class IterationPerformance < AdapterPerformance
+      attribute :time_per_iterations, :float
+      attribute :time_per_iteration, :float
+      attribute :iterations_per_second, :float
+      attribute :iterations_count, :integer
+    end
+
+    class MemoryPerformance < AdapterPerformance
+      attribute :total_allocated, :integer
+      attribute :total_retained, :integer
+      attribute :allocated_memory, :integer
+      attribute :retained_memory, :integer
+    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
+    end
+  end
+end

data/lib/serialbench/models/environment_config.rb

@@ -0,0 +1,71 @@
+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, values:
+        RubyBuildManager.list_definitions
+      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,59 @@
+# 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, values: RubyBuildManager.list_definitions
+
+      def self.current_local
+        new(
+          platform_string: "local-#{RUBY_VERSION}",
+          kind: 'local',
+          ruby_build_tag: RUBY_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
+    end
+  end
+end

data/lib/serialbench/models/result.rb

@@ -0,0 +1,53 @@
+# 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
+    end
+
+    class Result < Lutaml::Model::Serializable
+      attribute :platform, Platform
+      attribute :metadata, RunMetadata
+      attribute :environment_config, EnvironmentConfig
+      attribute :benchmark_config, BenchmarkConfig
+      attribute :benchmark_result, BenchmarkResult
+
+      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)
+
+        from_yaml(IO.read(data_file))
+      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,71 @@
+# 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)
+
+        # 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|
+          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

data/lib/serialbench/models/result_store.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'result'
+
+module Serialbench
+  module Models
+    class ResultStore
+      DEFAULT_BASE_PATH = 'results'
+      RUNS_PATH = 'runs'
+      SETS_PATH = 'sets'
+
+      attr_reader :base_path
+
+      def initialize(base_path = DEFAULT_BASE_PATH)
+        @base_path = base_path
+        ensure_results_directory
+      end
+
+      def self.default
+        @default ||= new
+      end
+
+      # Run management
+      def runs_path
+        File.join(@base_path, RUNS_PATH)
+      end
+
+      def find_runs(tags: nil, limit: nil)
+        runs = Result.find_all(runs_path)
+
+        runs = runs.select { |run| (Array(tags) - run.tags).empty? } if tags
+
+        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 = []
+
+        # 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)
+          Dir.glob(File.join(runs_path, '*')).each do |run_path|
+            next unless Dir.exist?(run_path)
+
+            begin
+              run = Result.load(run_path)
+              run.validate!
+            rescue StandardError => e
+              errors << "Invalid result at #{run_path}: #{e.message}"
+            end
+          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
+
+      def valid?
+        validate_structure.empty?
+      end
+
+      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
+end

data/lib/serialbench/models.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'models/benchmark_result'
+require_relative 'models/platform'
+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
+    # Factory method to create appropriate model based on data structure
+    def self.from_file(file_path)
+      case File.extname(file_path).downcase
+      when '.yaml', '.yml'
+        data = YAML.load_file(file_path)
+      when '.json'
+        data = JSON.parse(File.read(file_path))
+      else
+        raise ArgumentError, "Unsupported file format: #{File.extname(file_path)}"
+      end
+
+      from_data(data)
+    end
+
+    def self.from_data(data)
+      BenchmarkResult.new(data)
+    end
+
+    # Convert any benchmark result to YAML format
+    def self.to_yaml_file(result, file_path)
+      result.to_yaml_file(file_path)
+    end
+
+    # Convert any benchmark result to JSON format (for HTML templates)
+    def self.to_json_file(result, file_path)
+      result.to_json_file(file_path)
+    end
+
+    # Convenience methods for the new OO architecture
+    def self.result_store
+      ResultStore.default
+    end
+
+    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