serialbench 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7267d278bec24e38ca217bfbf164c10411f03b4fb333295f05c617c56f91a8b8
-  data.tar.gz: fcf4034a75ee9615197e2fd0cd3e7b63a795c7f3f0b1ba2c3b1cd0170babecb6
+  metadata.gz: fe9e6d376c22b6c6326017435378977a38426eaeba84a1284dfa9f488f18d3bb
+  data.tar.gz: 2d11e9d26b9f0e6669502741bf1c151b0807ca18c54c79c1ac2f6ba19b66a2cb
 SHA512:
-  metadata.gz: 4acd59cfc6d0b8d47d1d09172ea2f034063633ba5435fccc2fcfbd35ec11d96d41080210d84d149423979b3e14873cf3833512d36917515dfdb0ccdb698dfc1f
-  data.tar.gz: a913c26df13272e009996925fc6dd4789f74c6f968d27cd02da6155b71f1026d03e8bc2bb1cef1ba400ca19170b3c5a7f0d04ab125658ebf8a54c14551c5607b
+  metadata.gz: aa8cb879628d4b55671da1f54104f550f29c067af9e59471799728ed813ba2c428cb45457d6d90460e4ea5f9481a41c072c9a11e1237e37c4f407e3fd15e9854
+  data.tar.gz: a1cd5baddbca54dcc8ada57b3d5a3de4f566ad2a93cacb83281dbb7f16d44955827af1726f1027badb64a0e3a9f650121040430b04f9fd4edcb4e413e206cc3a

data/lib/serialbench/cli/base_cli.rb

@@ -46,6 +46,32 @@ module Serialbench
       def generate_timestamp
         Time.now.utc.strftime('%Y%m%d_%H%M%S')
       end
+
+      def load_environment_config(environment_config_path)
+        unless File.exist?(environment_config_path)
+          say "❌ Environment not found: #{environment_config_path}", :red
+          exit 1
+        end
+
+        require_relative '../models/environment_config'
+        Models::EnvironmentConfig.from_yaml(IO.read(environment_config_path))
+      rescue StandardError => e
+        say "❌ Failed to load environment config: #{e.message}", :red
+        exit 1
+      end
+
+      def load_benchmark_config(benchmark_config_path)
+        unless File.exist?(benchmark_config_path)
+          say "❌ Benchmark configuration file not found: #{benchmark_config_path}", :red
+          exit 1
+        end
+
+        require_relative '../models/benchmark_config'
+        Models::BenchmarkConfig.from_yaml(IO.read(benchmark_config_path))
+      rescue StandardError => e
+        say "❌ Failed to load benchmark config: #{e.message}", :red
+        exit 1
+      end
     end
   end
 end

data/lib/serialbench/cli/benchmark_cli.rb

@@ -76,22 +76,60 @@ module Serialbench
         say "Environment: #{environment.name} (#{environment.kind})", :cyan
         say "Configuration: #{benchmark_config_path}", :cyan
 
-        begin
-          # Execute benchmark based on environment type
-          case environment.kind
-          when 'local'
-            execute_local_benchmark(environment, config, benchmark_config_path)
-          when 'docker'
-            execute_docker_benchmark(environment, config, benchmark_config_path)
-          when 'asdf'
-            execute_asdf_benchmark(environment, config, benchmark_config_path)
-          else
-            raise "Unsupported environment type: #{environment.kind}"
-          end
-        rescue StandardError => e
-          say "❌ Error executing benchmark run: #{e.message}", :red
-          exit 1
+        result_dir = "results/runs/#{environment.name}-results"
+        FileUtils.mkdir_p(result_dir)
+
+        Runners.for(environment, environment_config_path)
+               .run_benchmark(config, benchmark_config_path, result_dir)
+
+        say '✅ Benchmark completed successfully!', :green
+        say "Results saved to: #{result_dir}", :cyan
+      rescue StandardError => e
+        say "❌ Error executing benchmark run: #{e.message}", :red
+        exit 1
+      end
+
+      desc 'create [NAME]', 'Generate a run configuration file'
+      long_desc <<~DESC
+        Generate a configuration file for a benchmark run.
+
+        NAME is optional - if not provided, a timestamped name will be generated.
+
+        Examples:
+          serialbench benchmark create                    # Creates config with timestamp
+          serialbench benchmark create my-benchmark       # Creates config/runs/my-benchmark.yml
+      DESC
+      option :formats, type: :array, default: %w[xml json yaml toml],
+                       desc: 'Formats to benchmark (xml, json, yaml, toml)'
+      option :warmup, type: :numeric, default: 3,
+                      desc: 'Number of warmup iterations'
+      option :data_sizes, type: :array, default: %w[small medium large],
+                          desc: 'Data sizes to test (small, medium, large)'
+      def create(name = nil)
+        raise 'Run name cannot be empty' if name&.strip&.empty?
+
+        validate_name(name)
+
+        config_dir = 'config/runs'
+        FileUtils.mkdir_p(config_dir)
+
+        benchmark_config_path = File.join(config_dir, "#{name}.yml")
+
+        if File.exist?(benchmark_config_path)
+          say "Configuration file already exists: #{benchmark_config_path}", :yellow
+          return unless yes?('Overwrite existing file? (y/n)')
         end
+
+        benchmark_config = Models::BenchmarkConfig.new(
+          formats: options[:formats],
+          warmup: options[:warmup],
+          data_sizes: options[:data_sizes]
+        )
+
+        benchmark_config.to_file(benchmark_config_path)
+
+        say "✅ Generated run configuration: #{benchmark_config_path}", :green
+        say 'Edit the file to customize benchmark settings', :cyan
       end
 
       desc '_docker_execute ENVIRONMENT_CONFIG_PATH BENCHMARK_CONFIG_PATH', '(Private) Execute a benchmark run'
@@ -242,77 +280,6 @@ module Serialbench
 
       private
 
-      def execute_local_benchmark(environment, config, benchmark_config_path)
-        say '🏠 Executing local benchmark', :green
-
-        runner = Serialbench::BenchmarkRunner.new(
-          environment_config: environment,
-          benchmark_config: config
-        )
-
-        # Run benchmarks
-        results = runner.run_all_benchmarks
-
-        platform = Serialbench::Models::Platform.current_local
-
-        metadata = Models::RunMetadata.new(
-          benchmark_config_path: benchmark_config_path,
-          environment_config_path: "config/environments/#{environment.name}.yml",
-          tags: [
-            'local',
-            platform.os,
-            platform.arch,
-            "ruby-#{environment.ruby_build_tag}"
-          ]
-        )
-
-        # Create results directory
-        result_dir = "results/runs/#{environment.name}-results"
-        FileUtils.mkdir_p(result_dir)
-
-        # Save results to single YAML file with platform and metadata merged in
-        results_model = Models::Result.new(
-          platform: platform,
-          metadata: metadata,
-          environment_config: environment,
-          benchmark_config: config,
-          benchmark_result: results
-        )
-
-        results_file = File.join(result_dir, 'results.yaml')
-        results_model.to_file(results_file)
-
-        say '✅ Local benchmark completed successfully!', :green
-        say "Results saved to: #{result_dir}", :cyan
-      rescue StandardError => e
-        say "❌ Local benchmark failed: #{e.message}", :red
-        say "Details: #{e.backtrace.first(3).join("\n")}", :white if options[:verbose]
-        raise e
-      end
-
-      def execute_docker_benchmark(environment, config, benchmark_config_path)
-        say '🐳 Executing Docker benchmark', :green
-
-        require_relative '../runners/docker_runner'
-
-        environment_config_path = "config/environments/#{environment.name}.yml"
-        runner = Runners::DockerRunner.new(environment, environment_config_path)
-
-        # Create results directory
-        result_dir = "results/runs/#{environment.name}-results"
-        FileUtils.mkdir_p(result_dir)
-
-        # Run benchmark
-        runner.run_benchmark(config, benchmark_config_path, result_dir)
-
-        say '✅ Docker benchmark completed successfully!', :green
-        say "Results saved to: #{result_dir}", :cyan
-      rescue StandardError => e
-        say "❌ Docker benchmark failed: #{e.message}", :red
-        say "Details: #{e.backtrace.first(3).join("\n")}", :white if options[:verbose]
-        raise e
-      end
-
       def show_execute_usage_and_exit
         say '❌ Error: Environment and config file arguments are required.', :red
         say ''
@@ -329,52 +296,6 @@ module Serialbench
         exit 1
       end
 
-      def load_environment_config(environment_config_path)
-        unless File.exist?(environment_config_path)
-          say "❌ Environment not found: #{environment_config_path}", :red
-          exit 1
-        end
-
-        Models::EnvironmentConfig.from_file(environment_config_path)
-      rescue StandardError => e
-        say "❌ Failed to load environment: #{e.message}", :red
-        say "Environment file: #{environment_config_path}", :white
-        exit 1
-      end
-
-      def load_benchmark_config(benchmark_config_path)
-        unless File.exist?(benchmark_config_path)
-          say "❌ Benchmark config not found: #{benchmark_config_path}", :red
-          exit 1
-        end
-
-        Models::BenchmarkConfig.from_file(benchmark_config_path)
-      rescue StandardError => e
-        say "❌ Failed to load benchmark config: #{e.message}", :red
-        say "Benchmark config file: #{benchmark_config_path}", :white
-        exit 1
-      end
-
-      def execute_asdf_benchmark(environment, config, benchmark_config_path)
-        say '🔧 Executing ASDF benchmark', :green
-
-        require_relative '../runners/asdf_runner'
-
-        environment_config_path = "config/environments/#{environment.name}.yml"
-        runner = Runners::AsdfRunner.new(environment, environment_config_path)
-
-        result_dir = "results/runs/#{environment.name}-results"
-        FileUtils.mkdir_p(result_dir)
-
-        runner.run_benchmark(config, benchmark_config_path, result_dir)
-
-        say '✅ ASDF benchmark completed successfully!', :green
-        say "Results saved to: #{result_dir}", :cyan
-      rescue StandardError => e
-        say "❌ ASDF benchmark failed: #{e.message}", :red
-        say "Details: #{e.backtrace.first(3).join("\n")}", :white if options[:verbose]
-        raise e
-      end
     end
   end
 end

data/lib/serialbench/cli/environment_cli.rb

@@ -30,7 +30,7 @@ module Serialbench
                             desc: 'Default Docker image for docker environments'
       option :dockerfile, type: :string, default: 'Dockerfile', desc: 'Default Dockerfile for docker environments'
       def new(name, kind, ruby_build_tag)
-        validate_environment_name!(name)
+        validate_name(name)
 
         config_path = File.join(options[:dir], "#{name}.yml")
 
@@ -39,15 +39,15 @@ module Serialbench
           return unless yes?('Overwrite existing environment? (y/n)')
         end
 
-        FileUtils.mkdir_p('config/environments')
+        FileUtils.mkdir_p(options[:dir])
 
         kind_config = case kind
                       when 'docker'
-                        raise unless options[:docker_image] && options[:dockerfile]
+                        raise ArgumentError, '--docker_image and --dockerfile are required for docker environments' unless options[:docker_image] && options[:dockerfile]
 
                         Models::EnvironmentConfig.new(
                           name: name,
-                          type: kind,
+                          kind: kind,
                           ruby_build_tag: ruby_build_tag,
                           docker: Models::DockerEnvConfig.new(
                             image: options[:docker_image],
@@ -58,19 +58,25 @@ module Serialbench
                       when 'asdf'
                         Models::EnvironmentConfig.new(
                           name: name,
-                          type: kind,
+                          kind: kind,
                           ruby_build_tag: ruby_build_tag,
                           asdf: Models::AsdfEnvConfig.new(auto_install: true),
                           description: "ASDF environment for Ruby #{ruby_build_tag} benchmarks"
                         )
+                      when 'local'
+                        Models::EnvironmentConfig.new(
+                          name: name,
+                          kind: kind,
+                          ruby_build_tag: ruby_build_tag,
+                          description: "Local environment for Ruby #{ruby_build_tag} benchmarks"
+                        )
+                      else
+                        raise ArgumentError, "unknown environment kind: #{kind} (expected local, docker, or asdf)"
                       end
         File.write(config_path, kind_config.to_yaml)
 
         say "✅ Created environment template: #{config_path}", :green
 
-        # Show ruby-build tag suggestion for local environments
-        show_ruby_build_suggestion if kind == 'local'
-
         say ''
         say 'Next steps:', :white
         say "1. Edit #{config_path} to confirm/change configuration", :cyan
@@ -99,7 +105,7 @@ module Serialbench
         FileUtils.mkdir_p(result_dir)
         say "Results will be saved to: #{result_dir}", :cyan
 
-        runner = create_environment_runner(environment_config, environment_path)
+        runner = Runners.for(environment_config, environment_path)
         runner.run_benchmark(benchmark_config, benchmark_config_path, result_dir)
 
         say '✅ Benchmark completed successfully!', :green
@@ -125,7 +131,7 @@ module Serialbench
 
         say "🔧 Preparing environment '#{environment_config.name}'...", :green
 
-        runner = create_environment_runner(environment_config, environment_config_path)
+        runner = Runners.for(environment_config, environment_config_path)
         runner.prepare
 
         say '✅ Environment prepared successfully!', :green
@@ -137,45 +143,8 @@ module Serialbench
 
       private
 
-      def load_benchmark_config(benchmark_config_path)
-        unless File.exist?(benchmark_config_path)
-          say "❌ Benchmark configuration file not found: #{benchmark_config_path}", :red
-          exit 1
-        end
 
-        Models::BenchmarkConfig.from_yaml(IO.read(benchmark_config_path))
-      rescue StandardError => e
-        say "❌ Failed to load benchmark config: #{e.message}", :red
-        exit 1
-      end
 
-      def load_environment_config(environment_config_path)
-        unless File.exist?(environment_config_path)
-          say "❌ Environment not found: #{environment_config_path}", :red
-          exit 1
-        end
-
-        Models::EnvironmentConfig.from_yaml(IO.read(environment_config_path))
-      rescue StandardError => e
-        say "❌ Failed to load environment config: #{e.message}", :red
-        exit 1
-      end
-
-      def create_environment_runner(environment_config, environment_config_path)
-        case environment_config.kind
-        when 'docker'
-          require_relative '../runners/docker_runner'
-          Runners::DockerRunner.new(environment_config, environment_config_path)
-        when 'asdf'
-          require_relative '../runners/asdf_runner'
-          Runners::AsdfRunner.new(environment_config, environment_config_path)
-        when 'local'
-          require_relative '../runners/local_runner'
-          Runners::LocalRunner.new(environment_config, environment_config_path)
-        else
-          raise "Unknown environment type: #{environment_config.kind}"
-        end
-      end
     end
   end
 end

data/lib/serialbench/runners/base.rb

@@ -7,8 +7,8 @@ require 'open3'
 require 'stringio'
 
 module Serialbench
-  # Handles ASDF-based benchmark execution
   module Runners
+    # Runner protocol: prepare, then run_benchmark(config, config_path, result_dir)
     class Base
       def initialize(environment_config, environment_config_path)
         @environment_config = environment_config
@@ -23,9 +23,8 @@ module Serialbench
         raise NotImplementedError, 'Subclasses must implement the prepare method'
       end
 
-      # Run benchmark
-      def benchmark
-        raise NotImplementedError, 'Subclasses must implement the benchmark method'
+      def run_benchmark(benchmark_config, benchmark_config_path, result_dir)
+        raise NotImplementedError, 'Subclasses must implement the run_benchmark method'
       end
     end
   end

data/lib/serialbench/runners.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'runners/base'
+require_relative 'runners/local_runner'
+require_relative 'runners/docker_runner'
+require_relative 'runners/asdf_runner'
+
+module Serialbench
+  # Executes benchmarks in an environment: local, docker, or asdf.
+  module Runners
+    def self.for(environment_config, environment_config_path)
+      runner_class = case environment_config.kind
+                     when 'local' then LocalRunner
+                     when 'docker' then DockerRunner
+                     when 'asdf' then AsdfRunner
+                     else raise ArgumentError, "unknown environment kind: #{environment_config.kind}"
+                     end
+
+      runner_class.new(environment_config, environment_config_path)
+    end
+  end
+end

data/lib/serialbench/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Serialbench
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/serialbench.rb

@@ -9,6 +9,7 @@ require_relative 'serialbench/models'
 
 module Serialbench
   autoload :TestData, 'serialbench/test_data'
+  autoload :Runners, 'serialbench/runners'
 
   class Error < StandardError; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serialbench
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ribose
@@ -308,6 +308,7 @@ files:
 - lib/serialbench/models/result.rb
 - lib/serialbench/models/result_store.rb
 - lib/serialbench/ruby_build_manager.rb
+- lib/serialbench/runners.rb
 - lib/serialbench/runners/asdf_runner.rb
 - lib/serialbench/runners/base.rb
 - lib/serialbench/runners/docker_runner.rb