serialbench 0.1.1 → 0.1.3

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,149 @@
+# frozen_string_literal: true
+
+require 'octokit'
+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
+
+        raise "Ruby-Build definition '#{tag}' not found. Available definitions: #{definitions.length}" unless definitions.include?(tag)
+
+        {
+          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
+        # 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']
+
+        client = Octokit::Client.new(client_options)
+
+        contents = client.contents('rbenv/ruby-build', path: 'share/ruby-build')
+
+        # Extract definition names from the file list
+        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)
+        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
+        return [] unless cache_exists?
+
+        cache_data = YAML.load_file(CACHE_FILE)
+        cache_data['definitions'] || []
+      rescue StandardError => e
+        warn "Warning: Failed to load Ruby-Build definitions from cache: #{e.message}"
+        []
+      end
+    end
+  end
+end

data/lib/serialbench/runners/asdf_runner.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'yaml'
+require 'open3'
+require 'stringio'
+require_relative '../benchmark_runner'
+require_relative 'base'
+
+module Serialbench
+  # Handles ASDF-based benchmark execution
+  module Runners
+    class AsdfRunner < Base
+      class AsdfError < StandardError; end
+
+      def initialize(environment_config, environment_config_path)
+        super
+        validate_asdf_available
+      end
+
+      # Prepare Ruby versions via ASDF
+      def prepare
+        puts '💎 Preparing Ruby versions via ASDF...'
+
+        ruby_version = @environment_config.ruby_build_tag
+        installed_versions = get_installed_ruby_versions
+
+        unless installed_versions.include?(ruby_version)
+          if @environment_config.asdf&.auto_install
+            install_missing_versions([ruby_version])
+          else
+            raise AsdfError,
+                  "Missing Ruby version: #{ruby_version}. Set auto_install: true to install automatically."
+          end
+        end
+
+        # Install gems for the Ruby version
+        install_gems_for_version(ruby_version)
+
+        puts '✅ Ruby version is prepared with gems installed'
+      end
+
+      # Run benchmark
+      def benchmark
+        puts '🚀 Running benchmarks...'
+
+        ruby_version = @environment_config.ruby_build_tag
+
+        raise AsdfError, 'Benchmark run failed' unless run_benchmark(ruby_version)
+
+        puts '✅ Completed 1 benchmark runs'
+        puts "📁 Individual results are available in: results/runs/#{@environment_name}"
+        puts '✅ ASDF benchmark completed successfully!'
+        puts "Results saved to: results/runs/#{@environment_name}"
+        puts "Generate site: serialbench benchmark build-site results/runs/#{@environment_name}"
+      end
+
+      private
+
+      # Validate ASDF is available
+      def validate_asdf_available
+        unless system('asdf --version > /dev/null 2>&1')
+          raise AsdfError,
+                'ASDF is not installed or not available in PATH'
+        end
+
+        # Check if ruby plugin is installed
+        return if system('asdf plugin list | grep -q ruby')
+
+        raise AsdfError, 'ASDF ruby plugin is not installed. Run: asdf plugin add ruby'
+      end
+
+      # Get list of installed Ruby versions
+      def get_installed_ruby_versions
+        output = `asdf list ruby 2>/dev/null`.strip
+        return [] if output.empty?
+
+        output.split("\n").map(&:strip).reject(&:empty?).map do |line|
+          # Remove leading asterisk and whitespace
+          line.gsub(/^\*?\s*/, '')
+        end
+      end
+
+      # Install missing Ruby versions
+      def install_missing_versions(versions)
+        puts "📦 Installing missing Ruby versions: #{versions.join(', ')}"
+
+        versions.each do |version|
+          puts "🔨 Installing Ruby #{version}..."
+
+          # Create temporary log directory
+          Dir.mktmpdir('asdf_install_ruby') do |temp_log_dir|
+            # Create a temporary file for logging
+            install_log = File.join(temp_log_dir, "install-ruby-#{version}.log")
+
+            success = false
+            Dir.chdir(temp_log_dir) do
+              success = system("asdf install ruby #{version} > #{install_log} 2>&1")
+            end
+
+            if success
+              puts "✅ Installed Ruby #{version}"
+            else
+              puts "❌ Failed to install Ruby #{version} (see #{install_log})"
+              raise AsdfError, "Failed to install Ruby #{version}"
+            end
+          end
+        end
+      end
+
+      # Install gems for a specific Ruby version
+      def install_gems_for_version(ruby_version)
+        puts "🔧 Installing gems for Ruby #{ruby_version}..."
+
+        # Create temporary log directory
+        temp_log_dir = "results/asdf-#{ruby_version}"
+        FileUtils.mkdir_p(temp_log_dir)
+        gem_install_log = File.join(temp_log_dir, "gems-ruby-#{ruby_version}.log")
+
+        # Use ASDF to install bundler and the serialbench gem
+        puts "   📦 Installing bundler and serialbench for Ruby #{ruby_version}..."
+        env = { 'ASDF_RUBY_VERSION' => ruby_version }
+        cmd = ['asdf', 'exec', 'gem', 'install', 'bundler', 'serialbench', '--no-document']
+
+        success = system(env, *cmd, out: gem_install_log, err: gem_install_log)
+        unless success
+          puts "❌ Failed to install gems for Ruby #{ruby_version} (see #{gem_install_log})"
+          raise AsdfError, "Failed to install gems for Ruby #{ruby_version}"
+        end
+
+        # ASDF doesn't need reshash like rbenv - gems are immediately available
+        puts "✅ Gems installed for Ruby #{ruby_version}"
+      end
+
+      # Run benchmark for specific Ruby version
+      def run_benchmark(benchmark_config, _benchmark_config_path, result_dir)
+        puts "🚀 Running benchmark for #{@name}..."
+
+        FileUtils.mkdir_p(result_dir)
+
+        prepare
+
+        ruby_version = @environment_config.ruby_build_tag
+        puts "🏃 Running benchmarks for Ruby #{ruby_version}..."
+        puts "   📁 Results will be saved to: #{result_dir}"
+
+        benchmark_log = File.join(result_dir, 'benchmark.log')
+
+        # Run benchmark directly using BenchmarkRunner instead of CLI
+        puts '   🚀 Starting benchmark execution...'
+
+        # Set ASDF Ruby version for this process
+        ENV['ASDF_RUBY_VERSION'] = ruby_version
+
+        # Capture stdout/stderr for logging
+        log_output = StringIO.new
+
+        runner = Serialbench::BenchmarkRunner.new(
+          benchmark_config: benchmark_config,
+          environment_config: @environment_config
+        )
+
+        # Run benchmarks and capture output
+        puts "   Running benchmarks with #{benchmark_config.iterations} iterations..."
+
+        # Redirect stdout to capture benchmark output
+        original_stdout = $stdout
+        $stdout = log_output
+
+        results = runner.run_all_benchmarks
+
+        # Restore stdout
+        $stdout = original_stdout
+
+        # Save benchmark results to results.yaml
+        results_file = File.join(result_dir, 'results.yaml')
+
+        # Create platform string
+        require_relative 'models/platform'
+        platform = Serialbench::Models::Platform.current_local
+        platform_string = "asdf-#{platform.os}-#{platform.arch}-ruby-#{ruby_version}"
+
+        # Create comprehensive results structure with platform and metadata merged in
+        full_results = {
+          'platform' => {
+            'platform_string' => platform_string,
+            'type' => 'asdf',
+            'os' => platform.os,
+            'arch' => platform.arch
+          },
+          'metadata' => {
+            'environment_name' => @environment_name,
+            'benchmark_config' => @benchmark_config,
+            'created_at' => Time.now.iso8601,
+            'tags' => ['asdf', platform.os, platform.arch, "ruby-#{ruby_version}"]
+          },
+          'environment' => {
+            'name' => @environment_name,
+            'type' => 'asdf',
+            'ruby_build_tag' => ruby_version,
+            'created_at' => Time.now.iso8601
+          },
+          'config' => {
+            'benchmark_config' => @benchmark_config,
+            'formats' => config['formats'],
+            'iterations' => config['iterations'],
+            'data_sizes' => config['data_sizes']
+          },
+          'results' => results
+        }
+
+        File.write(results_file, full_results.to_yaml)
+
+        # Save execution log
+        File.write(benchmark_log, log_output.string)
+
+        puts "✅ Completed Ruby #{ruby_version}"
+        puts "   Results saved to: #{results_file}"
+        puts "   Log saved to: #{benchmark_log}"
+        true
+      rescue StandardError => e
+        puts "❌ Failed Ruby #{ruby_version}: #{e.message}"
+        File.write(benchmark_log, "Error: #{e.message}\n#{e.backtrace.join("\n")}")
+        false
+      ensure
+        # Clean up environment variable and restore stdout
+        ENV.delete('ASDF_RUBY_VERSION')
+        $stdout = original_stdout if defined?(original_stdout)
+      end
+
+      # Process and merge results
+      def process_results(successful_runs)
+        puts "📊 Processing #{successful_runs} successful results..."
+
+        # Find all result directories with valid results
+        # Look for directories that contain results/runs subdirectories
+        result_dirs = Dir.glob(File.join(@output_dir, 'asdf-*')).select do |dir|
+          results_runs_dir = File.join(dir, 'results', 'runs')
+          Dir.exist?(results_runs_dir) && !Dir.glob(File.join(results_runs_dir, '*')).empty?
+        end
+
+        if result_dirs.empty?
+          puts '⚠️  No results found for processing, but benchmarks completed successfully!'
+          puts "📁 Individual results are available in: #{@output_dir}"
+          return
+        end
+
+        puts '🎉 Results processed successfully!'
+        puts "📁 Results directory: #{@output_dir}"
+        puts '📊 Individual benchmark results available in:'
+        result_dirs.each do |dir|
+          puts "   - #{dir}"
+        end
+        puts ''
+        puts '💡 To create a comparison report, use:'
+        puts '   serialbench resultset new multi-ruby-comparison'
+        result_dirs.each do |dir|
+          result_name = File.basename(dir)
+          puts "   serialbench resultset add-result multi-ruby-comparison #{result_name}"
+        end
+        puts '   serialbench resultset build-site multi-ruby-comparison'
+      end
+
+      # Generate combined platform string for directory naming
+      # Format: asdf-{os}-{arch}-ruby-{version}
+      def generate_platform_string(runner_type, ruby_version)
+        # Get OS name
+        os = case RUBY_PLATFORM
+             when /darwin/
+               'macos'
+             when /linux/
+               'linux'
+             when /mswin|mingw|cygwin/
+               'windows'
+             else
+               'unknown'
+             end
+
+        # Get architecture (simplified)
+        arch = case RUBY_PLATFORM
+               when /x86_64|amd64/
+                 'x64'
+               when /arm64|aarch64/
+                 'arm64'
+               when /i386|i686/
+                 'x86'
+               else
+                 'unknown'
+               end
+
+        "#{runner_type}-#{os}-#{arch}-ruby-#{ruby_version}"
+      end
+    end
+  end
+end

data/lib/serialbench/runners/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'yaml'
+require 'open3'
+require 'stringio'
+
+module Serialbench
+  # Handles ASDF-based benchmark execution
+  module Runners
+    class Base
+      def initialize(environment_config, environment_config_path)
+        @environment_config = environment_config
+        @environment_config_path = environment_config_path
+
+        raise 'environment_config is required' unless @environment_config
+        raise 'environment_config_path is required' unless @environment_config_path
+        raise 'environment_config_path must be a valid file' unless File.exist?(@environment_config_path)
+      end
+
+      def prepare
+        raise NotImplementedError, 'Subclasses must implement the prepare method'
+      end
+
+      # Run benchmark
+      def benchmark
+        raise NotImplementedError, 'Subclasses must implement the benchmark method'
+      end
+    end
+  end
+end