serialbench 0.1.0 → 0.1.2

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

data/lib/serialbench/ruby_build_manager.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'fileutils'
+
+module Serialbench
+  # Manages Ruby-Build definitions from the official ruby-build repository
+  class RubyBuildManager
+    GITHUB_API_URL = 'https://api.github.com/repos/rbenv/ruby-build/contents/share/ruby-build'
+    CACHE_DIR = File.expand_path('~/.serialbench')
+    CACHE_FILE = File.join(CACHE_DIR, 'ruby-build-definitions.yaml')
+
+    class << self
+      def update_definitions
+        puts '🔄 Fetching Ruby-Build definitions from GitHub...'
+
+        definitions = fetch_definitions_from_github
+        save_definitions_to_cache(definitions)
+
+        puts "✅ Updated #{definitions.length} Ruby-Build definitions"
+        puts "📁 Cache location: #{CACHE_FILE}"
+
+        definitions
+      rescue StandardError => e
+        raise "Failed to update Ruby-Build definitions: #{e.message}"
+      end
+
+      def list_definitions
+        load_definitions_from_cache
+      end
+
+      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
+
+        {
+          tag: tag,
+          available: true,
+          source: 'ruby-build',
+          cache_file: CACHE_FILE
+        }
+      end
+
+      def validate_tag(tag)
+        puts "🔍 Validating Ruby-Build tag: #{tag} against #{CACHE_FILE}"
+        return false if tag.nil? || tag.strip.empty?
+
+        definitions = load_definitions_from_cache
+        definitions.include?(tag)
+      rescue StandardError
+        false
+      end
+
+      def suggest_current_ruby_tag
+        ruby_version = RUBY_VERSION
+
+        # Try exact match first
+        return ruby_version if validate_tag(ruby_version)
+
+        # Try common variations
+        variations = [
+          ruby_version,
+          "#{ruby_version}.0",
+          ruby_version.split('.')[0..1].join('.') + '.0'
+        ]
+
+        variations.each do |variation|
+          return variation if validate_tag(variation)
+        end
+
+        # Return the Ruby version even if not found, user can adjust
+        ruby_version
+      end
+
+      def cache_exists?
+        File.exist?(CACHE_FILE)
+      end
+
+      def cache_age
+        return nil unless cache_exists?
+
+        Time.now - File.mtime(CACHE_FILE)
+      end
+
+      def ensure_cache_exists!
+        return if cache_exists?
+
+        raise <<~ERROR
+          Ruby-Build definitions cache not found.
+
+          Update the cache first:
+            serialbench ruby-build update
+        ERROR
+      end
+
+      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)
+
+        raise "GitHub API request failed: #{response.code} #{response.message}" unless response.code == '200'
+
+        data = JSON.parse(response.body)
+
+        # Extract definition names from the file list
+        definitions = data
+                      .select { |item| item['type'] == 'file' }
+                      .map { |item| item['name'] }
+                      .sort
+
+        raise 'No Ruby-Build definitions found in GitHub response' if definitions.empty?
+
+        definitions
+      end
+
+      def save_definitions_to_cache(definitions)
+        FileUtils.mkdir_p(CACHE_DIR)
+
+        cache_data = {
+          'updated_at' => Time.now.utc.iso8601,
+          'source' => GITHUB_API_URL,
+          'count' => definitions.length,
+          'definitions' => definitions
+        }
+
+        File.write(CACHE_FILE, cache_data.to_yaml)
+      end
+
+      def load_definitions_from_cache
+        ensure_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}"
+      end
+    end
+  end
+end