serialbench 0.1.0 → 0.1.2

data/lib/serialbench/cli.rb

@@ -1,438 +1,87 @@
 # frozen_string_literal: true
 
 require 'thor'
-require 'json'
-require 'yaml'
-require 'fileutils'
+require_relative 'cli/base_cli'
+require_relative 'cli/environment_cli'
+require_relative 'cli/benchmark_cli'
+require_relative 'cli/resultset_cli'
+require_relative 'cli/ruby_build_cli'
 
 module Serialbench
-  # Thor-based command line interface for SerialBench
-  class Cli < Thor
-    include Thor::Actions
+  # Main CLI entry point for the new object-oriented command structure
+  class CLI < Serialbench::Cli::BaseCli
+    desc 'environment SUBCOMMAND', 'Manage benchmark environments'
+    subcommand 'environment', Serialbench::Cli::EnvironmentCli
 
-    desc 'benchmark', 'Run serialization benchmarks'
-    long_desc <<~DESC
-      Run the complete benchmark suite for all available serialization libraries.
+    desc 'benchmark SUBCOMMAND', 'Manage individual benchmark runs'
+    subcommand 'benchmark', Serialbench::Cli::BenchmarkCli
 
-      This command will test parsing, generation, streaming, and memory usage
-      across XML, JSON, and TOML formats using all available libraries.
-    DESC
-    option :formats, type: :array, default: %w[xml json toml],
-                     desc: 'Formats to benchmark (xml, json, toml)'
-    option :output_format, type: :string, default: 'all',
-                           desc: 'Output format: all, json, yaml, html'
-    option :parsing_only, type: :boolean, default: false,
-                          desc: 'Run only parsing benchmarks'
-    option :generation_only, type: :boolean, default: false,
-                             desc: 'Run only generation benchmarks'
-    option :streaming_only, type: :boolean, default: false,
-                            desc: 'Run only streaming benchmarks'
-    option :memory_only, type: :boolean, default: false,
-                         desc: 'Run only memory usage benchmarks'
-    option :iterations, type: :numeric, default: 10,
-                        desc: 'Number of benchmark iterations'
-    option :warmup, type: :numeric, default: 3,
-                    desc: 'Number of warmup iterations'
-    def benchmark
-      say 'SerialBench - Comprehensive Serialization Performance Tests', :green
-      say '=' * 70, :green
+    desc 'resultset SUBCOMMAND', 'Manage benchmark resultsets (collections of runs)'
+    subcommand 'resultset', Serialbench::Cli::ResultsetCli
 
-      # Validate formats
-      valid_formats = %w[xml json toml]
-      invalid_formats = options[:formats] - valid_formats
-      unless invalid_formats.empty?
-        say "Invalid formats: #{invalid_formats.join(', ')}", :red
-        say "Valid formats: #{valid_formats.join(', ')}", :yellow
-        exit 1
-      end
-
-      # Convert format strings to symbols
-      formats = options[:formats].map(&:to_sym)
-
-      # Show available serializers
-      show_available_serializers(formats)
-
-      # Run benchmarks
-      runner_options = {
-        formats: formats,
-        iterations: options[:iterations],
-        warmup: options[:warmup]
-      }
+    desc 'ruby_build SUBCOMMAND', 'Manage Ruby-Build definitions for validation'
+    subcommand 'ruby_build', Serialbench::Cli::RubyBuildCli
 
-      runner = Serialbench::BenchmarkRunner.new(**runner_options)
-
-      begin
-        results = run_selected_benchmarks(runner)
-        save_results(results)
-        show_summary(results) unless %w[json yaml].include?(options[:output_format])
-      rescue StandardError => e
-        say "Error running benchmarks: #{e.message}", :red
-        say e.backtrace.first(5).join("\n"), :red if ENV['DEBUG']
-        exit 1
-      end
+    desc 'version', 'Show Serialbench version'
+    def self.version
+      puts "Serialbench version #{Serialbench::VERSION}"
     end
 
-    desc 'list', 'List available serializers'
-    long_desc <<~DESC
-      Display all available serialization libraries grouped by format.
-
-      Shows which libraries are installed and available for benchmarking,
-      along with their versions.
-    DESC
-    option :format, type: :string, desc: 'Show only serializers for specific format'
-    def list
-      say 'Available Serializers', :green
-      say '=' * 30, :green
-
-      if options[:format]
-        format_sym = options[:format].to_sym
-        serializers = Serialbench::Serializers.available_for_format(format_sym)
-
-        if serializers.empty?
-          say "No available serializers for format: #{options[:format]}", :yellow
-        else
-          show_serializers_for_format(format_sym, serializers)
-        end
+    desc 'help [COMMAND]', 'Show help for commands'
+    def help(command = nil)
+      if command
+        super(command)
       else
-        %i[xml json toml].each do |format|
-          serializers = Serialbench::Serializers.available_for_format(format)
-          next if serializers.empty?
-
-          show_serializers_for_format(format, serializers)
-          say ''
-        end
-      end
-    end
-
-    desc 'version', 'Show SerialBench version'
-    def version
-      say "SerialBench version #{Serialbench::VERSION}", :green
-    end
-
-    desc 'merge_results INPUT_DIRS... OUTPUT_DIR', 'Merge benchmark results from multiple runs'
-    long_desc <<~DESC
-      Merge benchmark results from multiple Ruby versions or different environments.
-
-      INPUT_DIRS should contain results.json files from different benchmark runs.
-      OUTPUT_DIR will contain the merged results and comparative reports.
-
-      Example:
-        serialbench merge_results ruby-3.0/results ruby-3.1/results ruby-3.2/results merged_output/
-    DESC
-    def merge_results(*args)
-      if args.length < 2
-        say 'Error: Need at least one input directory and one output directory', :red
-        say 'Usage: serialbench merge_results INPUT_DIRS... OUTPUT_DIR', :yellow
-        exit 1
-      end
-
-      output_dir = args.pop
-      input_dirs = args
-
-      say "Merging benchmark results from #{input_dirs.length} directories to #{output_dir}", :green
-
-      begin
-        merger = Serialbench::ResultMerger.new
-        merged_file = merger.merge_directories(input_dirs, output_dir)
-        say "Results merged successfully to: #{merged_file}", :green
-      rescue StandardError => e
-        say "Error merging results: #{e.message}", :red
-        exit 1
-      end
-    end
-
-    desc 'github_pages INPUT_DIRS... OUTPUT_DIR', 'Generate GitHub Pages HTML from multiple benchmark runs'
-    long_desc <<~DESC
-      Merge benchmark results from multiple Ruby versions and generate a GitHub Pages compatible HTML report.
-
-      INPUT_DIRS should contain results.json files from different benchmark runs.
-      OUTPUT_DIR will contain index.html and styles.css ready for GitHub Pages deployment.
+        puts <<~HELP
+          Serialbench - Benchmarking Framework for Ruby Serialization Libraries
 
-      This command combines merge_results and HTML generation in one step.
+          USAGE:
+            serialbench COMMAND [SUBCOMMAND] [OPTIONS]
 
-      Example:
-        serialbench github_pages ruby-3.0/results ruby-3.1/results ruby-3.2/results docs/
-    DESC
-    def github_pages(*args)
-      if args.length < 2
-        say 'Error: Need at least one input directory and one output directory', :red
-        say 'Usage: serialbench github_pages INPUT_DIRS... OUTPUT_DIR', :yellow
-        exit 1
-      end
+          COMMANDS:
+            environment   Manage benchmark environments (Docker, ASDF, Local)
+            benchmark     Manage individual benchmark runs
+            resultset     Manage benchmark resultsets (collections of runs)
+            ruby-build    Manage Ruby-Build definitions for validation
+            version       Show version information
+            help          Show this help message
 
-      output_dir = args.pop
-      input_dirs = args
+          EXAMPLES:
+            # Create a Docker environment
+            serialbench environment new docker-test docker
 
-      say "Generating GitHub Pages from #{input_dirs.length} benchmark directories", :green
+            # Run multi-environment benchmarks
+            serialbench environment multi-execute asdf --config=serialbench-asdf.yml
+            serialbench environment multi-execute docker --config=serialbench-docker.yml
 
-      begin
-        merger = Serialbench::ResultMerger.new
+            # Create and execute a benchmark
+            serialbench benchmark create my-benchmark
+            serialbench benchmark execute my-benchmark.yml
 
-        # Merge results
-        say 'Step 1: Merging benchmark results...', :yellow
-        merger.merge_directories(input_dirs, output_dir)
+            # Create a result set for comparison
+            serialbench resultset create comparison-set
+            serialbench resultset add-result comparison-set results/my-benchmark
 
-        # Generate GitHub Pages HTML
-        say 'Step 2: Generating GitHub Pages HTML...', :yellow
-        files = merger.generate_github_pages_html(output_dir)
+            # Generate static sites
+            serialbench benchmark build-site results/my-benchmark
+            serialbench resultset build-site resultsets/comparison-set
 
-        say 'GitHub Pages generated successfully!', :green
-        say 'Files created:', :cyan
-        say "  HTML: #{files[:html]}", :white
-        say "  CSS: #{files[:css]}", :white
-        say '', :white
-        say 'To deploy to GitHub Pages:', :cyan
-        say '1. Commit and push the generated files to your repository', :white
-        say '2. Enable GitHub Pages in repository settings', :white
-        say '3. Set source to the branch containing these files', :white
-      rescue StandardError => e
-        say "Error generating GitHub Pages: #{e.message}", :red
-        exit 1
+          For detailed help on any command, use:
+            serialbench COMMAND help
+        HELP
       end
     end
 
-    desc 'generate_reports DATA_FILE', 'Generate reports from benchmark data'
-    long_desc <<~DESC
-      Generate HTML and AsciiDoc reports from existing benchmark data.
-
-      DATA_FILE should be a JSON file containing benchmark results.
-    DESC
-    def generate_reports(data_file)
-      say "Generating reports from data in #{data_file}", :green
-
-      unless File.exist?(data_file)
-        say "Data file does not exist: #{data_file}", :red
-        exit 1
-      end
-
-      begin
-        Serialbench.generate_reports_from_data(data_file)
-        say 'Reports generated successfully!', :green
-      rescue StandardError => e
-        say "Error generating reports: #{e.message}", :red
-        exit 1
-      end
-    end
-
-    private
-
-    def show_available_serializers(formats)
-      say "\nAvailable serializers:", :cyan
-
-      formats.each do |format|
-        serializers = Serialbench::Serializers.available_for_format(format)
-        next if serializers.empty?
-
-        serializer_names = serializers.map do |serializer_class|
-          serializer = serializer_class.new
-          "#{serializer.name} v#{serializer.version}"
-        end
-
-        say "  #{format.upcase}: #{serializer_names.join(', ')}", :white
-      end
-
-      say "\nTest data sizes: small, medium, large", :cyan
-      say ''
-    end
-
-    def show_serializers_for_format(format, serializers)
-      say "#{format.upcase}:", :cyan
-
-      serializers.each do |serializer_class|
-        serializer = serializer_class.new
-        features = []
-        features << 'streaming' if serializer.supports_streaming?
-        features << 'built-in' if %w[json rexml].include?(serializer.name)
-
-        feature_text = features.empty? ? '' : " (#{features.join(', ')})"
-        say "  ✓ #{serializer.name} v#{serializer.version}#{feature_text}", :green
-      end
-    end
-
-    def run_selected_benchmarks(runner)
-      results = { environment: runner.environment_info }
-
-      if options[:parsing_only]
-        say 'Running parsing benchmarks...', :yellow
-        results[:parsing] = runner.run_parsing_benchmarks
-      elsif options[:generation_only]
-        say 'Running generation benchmarks...', :yellow
-        results[:generation] = runner.run_generation_benchmarks
-      elsif options[:streaming_only]
-        say 'Running streaming benchmarks...', :yellow
-        results[:streaming] = runner.run_streaming_benchmarks
-      elsif options[:memory_only]
-        say 'Running memory benchmarks...', :yellow
-        results[:memory_usage] = runner.run_memory_benchmarks
-      else
-        say 'Running all benchmarks...', :yellow
-        results = runner.run_all_benchmarks
-      end
-
-      results
+    # Handle unknown commands gracefully
+    def method_missing(method_name, *args)
+      puts "Unknown command: #{method_name}"
+      puts ''
+      help
+      exit 1
     end
 
-    def save_results(results)
-      case options[:output_format]
-      when 'json'
-        save_json_results(results)
-      when 'yaml'
-        save_yaml_results(results)
-      when 'html'
-        generate_html_reports(results)
-      else
-        # Generate all formats
-        save_json_results(results)
-        save_yaml_results(results)
-        generate_html_reports(results)
-      end
-
-      show_generated_files
-    end
-
-    def save_json_results(results)
-      FileUtils.mkdir_p('results/data')
-
-      # Add Ruby version to results
-      results[:ruby_version] = RUBY_VERSION
-      results[:ruby_platform] = RUBY_PLATFORM
-      results[:timestamp] = Time.now.iso8601
-
-      File.write('results/data/results.json', JSON.pretty_generate(results))
-      say 'JSON results saved to: results/data/results.json', :green
-    end
-
-    def save_yaml_results(results)
-      FileUtils.mkdir_p('results/data')
-
-      # Add Ruby version to results
-      results[:ruby_version] = RUBY_VERSION
-      results[:ruby_platform] = RUBY_PLATFORM
-      results[:timestamp] = Time.now.iso8601
-
-      File.write('results/data/results.yaml', results.to_yaml)
-      say 'YAML results saved to: results/data/results.yaml', :green
-    end
-
-    def generate_html_reports(results)
-      say 'Generating reports...', :yellow
-      report_files = Serialbench.generate_reports(results)
-
-      say 'Reports generated:', :green
-      say "  HTML: #{report_files[:html]}", :white
-      say "  CSS: #{report_files[:css]}", :white
-    end
-
-    def show_generated_files
-      case options[:output_format]
-      when 'json'
-        say 'Files generated:', :cyan
-        say '  JSON: results/data/results.json', :white
-      when 'yaml'
-        say 'Files generated:', :cyan
-        say '  YAML: results/data/results.yaml', :white
-      when 'html'
-        say 'Files generated:', :cyan
-        say '  HTML: results/reports/benchmark_report.html', :white
-        say '  Charts: results/charts/*.svg', :white
-      else
-        say 'Files generated:', :cyan
-        say '  JSON: results/data/results.json', :white
-        say '  YAML: results/data/results.yaml', :white
-        say '  HTML: results/reports/benchmark_report.html', :white
-        say '  Charts: results/charts/*.svg', :white
-      end
-    end
-
-    def show_summary(results)
-      return unless results[:parsing] || results[:generation]
-
-      say "\n" + '=' * 50, :green
-      say 'BENCHMARK SUMMARY', :green
-      say '=' * 50, :green
-
-      show_parsing_summary(results[:parsing]) if results[:parsing]
-
-      show_generation_summary(results[:generation]) if results[:generation]
-
-      return unless results[:memory_usage]
-
-      show_memory_summary(results[:memory_usage])
-    end
-
-    def show_parsing_summary(parsing_results)
-      say "\nParsing Performance (operations/second):", :cyan
-
-      %i[small medium large].each do |size|
-        next unless parsing_results[size]
-
-        say "\n  #{size.capitalize} files:", :yellow
-
-        # Flatten the nested structure and sort by performance
-        flattened_results = []
-        parsing_results[size].each do |format, serializers|
-          serializers.each do |serializer_name, data|
-            flattened_results << ["#{format}/#{serializer_name}", data]
-          end
-        end
-
-        sorted_results = flattened_results.sort_by { |_, data| -data[:iterations_per_second] }
-
-        sorted_results.each do |serializer_name, data|
-          ops_per_sec = data[:iterations_per_second].round(2)
-          say "    #{serializer_name}: #{ops_per_sec} ops/sec", :white
-        end
-      end
-    end
-
-    def show_generation_summary(generation_results)
-      say "\nGeneration Performance (operations/second):", :cyan
-
-      %i[small medium large].each do |size|
-        next unless generation_results[size]
-
-        say "\n  #{size.capitalize} files:", :yellow
-
-        # Flatten the nested structure and sort by performance
-        flattened_results = []
-        generation_results[size].each do |format, serializers|
-          serializers.each do |serializer_name, data|
-            flattened_results << ["#{format}/#{serializer_name}", data]
-          end
-        end
-
-        sorted_results = flattened_results.sort_by { |_, data| -data[:iterations_per_second] }
-
-        sorted_results.each do |serializer_name, data|
-          ops_per_sec = data[:iterations_per_second].round(2)
-          say "    #{serializer_name}: #{ops_per_sec} ops/sec", :white
-        end
-      end
-    end
-
-    def show_memory_summary(memory_results)
-      say "\nMemory Usage (MB):", :cyan
-
-      %i[small medium large].each do |size|
-        next unless memory_results[size]
-
-        say "\n  #{size.capitalize} files:", :yellow
-
-        # Flatten the nested structure and sort by memory usage (ascending)
-        flattened_results = []
-        memory_results[size].each do |format, serializers|
-          serializers.each do |serializer_name, data|
-            flattened_results << ["#{format}/#{serializer_name}", data]
-          end
-        end
-
-        sorted_results = flattened_results.sort_by { |_, data| data[:allocated_memory] }
-
-        sorted_results.each do |serializer_name, data|
-          memory_mb = (data[:allocated_memory] / 1024.0 / 1024.0).round(2)
-          say "    #{serializer_name}: #{memory_mb} MB", :white
-        end
-      end
+    def respond_to_missing?(method_name, include_private = false)
+      false
     end
   end
 end

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