feat: add go-compatible CLI

Author: not-matthias

go-runner/src/builder/mod.rs

@@ -0,0 +1,6 @@
+pub mod discovery;
+pub mod patcher;
+pub mod templater;
+pub mod verifier;
+
+pub use discovery::*;

go-runner/src/cli.rs

@@ -0,0 +1,153 @@
+#[derive(Debug)]
+pub enum CliExit {
+    Help,
+    Version,
+    MissingArgument,
+    UnknownFlag,
+}
+
+#[derive(Debug)]
+pub struct Cli {
+    /// Run only benchmarks matching regexp
+    pub bench: String,
+}
+
+impl Cli {
+    pub fn parse() -> Self {
+        match Self::parse_args(std::env::args().skip(1)) {
+            Ok(cli) => cli,
+            Err(CliExit::Help) => std::process::exit(0),
+            Err(CliExit::Version) => std::process::exit(0),
+            Err(CliExit::MissingArgument) => std::process::exit(2),
+            Err(CliExit::UnknownFlag) => std::process::exit(1),
+        }
+    }
+
+    fn parse_args(mut args: impl Iterator<Item = String>) -> Result<Self, CliExit> {
+        let mut bench = ".".to_string();
+
+        // We currently only support the `test` subcommand.
+        let cmd = args.next();
+        assert!(
+            cmd == Some("test".to_string()),
+            "Expected 'test' as the first argument, got {cmd:?}",
+        );
+
+        while let Some(arg) = args.next() {
+            match arg.as_str() {
+                "-h" | "--help" => {
+                    println!(
+                        "\
+The Codspeed Go Benchmark Runner
+
+USAGE:
+    go-runner test [OPTIONS]
+
+OPTIONS:
+    -bench <pattern>     Run only benchmarks matching regexp (defaults to '.')
+    -h, --help           Print help information
+    -V, --version        Print version information"
+                    );
+                    return Err(CliExit::Help);
+                }
+                "-V" | "--version" => {
+                    println!("{}", env!("CARGO_PKG_VERSION"));
+                    return Err(CliExit::Version);
+                }
+                "-bench" => {
+                    bench = args.next().ok_or_else(|| {
+                        eprintln!("error: `-bench` requires a pattern");
+                        CliExit::MissingArgument
+                    })?;
+                }
+                s if s.starts_with("-bench=") => {
+                    bench = s.split_once('=').unwrap().1.to_string();
+                }
+
+                s if s.starts_with('-') => {
+                    eprintln!("Unknown flag: {s}");
+                    return Err(CliExit::UnknownFlag);
+                }
+
+                _ => {
+                    eprintln!(
+                        "warning: package arguments are not currently supported, ignoring '{arg}'"
+                    );
+                    // Consume and ignore all remaining arguments
+                    for remaining_arg in args {
+                        eprintln!(
+                            "warning: package arguments are not currently supported, ignoring '{remaining_arg}'"
+                        );
+                    }
+                    break;
+                }
+            }
+        }
+        Ok(Self { bench })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn str_to_iter(cmd: &str) -> Result<Cli, CliExit> {
+        let args: Vec<String> = if cmd.trim().is_empty() {
+            Vec::new()
+        } else {
+            cmd.split_whitespace()
+                .map(|s| s.to_string())
+                .skip(1)
+                .collect()
+        };
+        Cli::parse_args(args.into_iter())
+    }
+
+    #[test]
+    fn test_cli_parse_defaults() {
+        let cli = str_to_iter("go-runner test").unwrap();
+        assert_eq!(cli.bench, ".");
+    }
+
+    #[test]
+    fn test_cli_parse_with_bench_flag() {
+        let cli = str_to_iter("go-runner test -bench Test").unwrap();
+        assert_eq!(cli.bench, "Test");
+
+        let cli = str_to_iter("go-runner test -bench=BenchmarkFoo").unwrap();
+        assert_eq!(cli.bench, "BenchmarkFoo");
+    }
+
+    #[test]
+    fn test_cli_parse_ignores_packages() {
+        let cli = str_to_iter("go-runner test package1 package2").unwrap();
+        assert_eq!(cli.bench, ".");
+    }
+
+    #[test]
+    fn test_cli_parse_help_flag() {
+        let result = str_to_iter("go-runner test -h");
+        assert!(matches!(result, Err(CliExit::Help)));
+
+        let result = str_to_iter("go-runner test --help");
+        assert!(matches!(result, Err(CliExit::Help)));
+    }
+
+    #[test]
+    fn test_cli_parse_version_flag() {
+        let result = str_to_iter("go-runner test -V");
+        assert!(matches!(result, Err(CliExit::Version)));
+
+        let result = str_to_iter("go-runner test --version");
+        assert!(matches!(result, Err(CliExit::Version)));
+    }
+
+    #[test]
+    fn test_cli_parse_invalid() {
+        let result = str_to_iter("go-runner test -bench");
+        assert!(matches!(result, Err(CliExit::MissingArgument)));
+
+        let result = str_to_iter("go-runner test -unknown");
+        assert!(matches!(result, Err(CliExit::UnknownFlag)));
+    }
+}

go-runner/src/lib.rs

@@ -0,0 +1,104 @@
+use crate::{builder::BenchmarkPackage, prelude::*};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+mod builder;
+pub mod cli;
+pub mod prelude;
+mod results;
+mod runner;
+pub(crate) mod utils;
+
+#[cfg(test)]
+mod integration_tests;
+
+/// Builds and runs the specified Go project benchmarks, writing results to the .codspeed folder.
+pub fn run_benchmarks(project_dir: &Path, bench: &str) -> anyhow::Result<()> {
+    let profile_dir = std::env::var("CODSPEED_PROFILE_FOLDER")
+        .context("CODSPEED_PROFILE_FOLDER env var not set")?;
+    std::fs::remove_dir_all(&profile_dir).ok();
+
+    // 1. Build phase - Benchmark and package discovery
+    let packages = BenchmarkPackage::from_project(project_dir)?;
+    info!("Discovered {} packages", packages.len());
+
+    let mut bench_name_to_path = HashMap::new();
+    for package in &packages {
+        for benchmark in &package.benchmarks {
+            bench_name_to_path.insert(benchmark.name.clone(), benchmark.file_path.clone());
+        }
+    }
+
+    let total_benchmarks: usize = packages.iter().map(|p| p.benchmarks.len()).sum();
+    info!("Total benchmarks discovered: {total_benchmarks}");
+    for (name, path) in &bench_name_to_path {
+        info!("Found {name:30} in {path:?}");
+    }
+
+    // 2. Generate codspeed runners and execute them
+    for package in &packages {
+        info!("Generating custom runner for package: {}", package.name);
+        let (_target_dir, runner_path) = builder::templater::run(package)?;
+
+        let args = [
+            "-test.bench",
+            bench,
+            // Use a single iteration in tests to speed up execution, otherwise use 5 seconds
+            "-test.benchtime",
+            if cfg!(test) || std::env::var("CODSPEED_ENV").is_err() {
+                "1x"
+            } else {
+                "5s"
+            },
+        ];
+
+        info!("Running benchmarks for package: {}", package.name);
+        runner::run(&runner_path, &args)?;
+    }
+
+    // 3. Collect the results
+    collect_walltime_results(bench_name_to_path)?;
+
+    Ok(())
+}
+
+// TODO: This should be merged with codspeed-rust/codspeed/walltime_results.rs
+fn collect_walltime_results(bench_name_to_path: HashMap<String, PathBuf>) -> anyhow::Result<()> {
+    let profile_dir = std::env::var("CODSPEED_PROFILE_FOLDER")
+        .context("CODSPEED_PROFILE_FOLDER env var not set")?;
+    let profile_dir = PathBuf::from(&profile_dir);
+    let raw_results = results::raw_result::RawResult::parse_folder(&profile_dir)?;
+    info!("Parsed {} raw results", raw_results.len());
+
+    let mut benchmarks_by_pid: HashMap<u32, Vec<results::walltime_results::WalltimeBenchmark>> =
+        HashMap::new();
+    for raw in raw_results {
+        let file_path = bench_name_to_path
+            .get(&raw.benchmark_name)
+            .map(|p| p.to_string_lossy().to_string());
+        benchmarks_by_pid
+            .entry(raw.pid)
+            .or_default()
+            .push(raw.into_walltime_benchmark(file_path));
+    }
+
+    for (pid, walltime_benchmarks) in benchmarks_by_pid {
+        let creator = results::walltime_results::Creator {
+            name: "codspeed-go".into(),
+            version: env!("CARGO_PKG_VERSION").into(),
+            pid,
+        };
+        let results_dir = profile_dir.join("results");
+        std::fs::create_dir_all(&results_dir)?;
+
+        let results_file = results_dir.join(format!("{pid}.json"));
+        let walltime_results =
+            results::walltime_results::WalltimeResults::new(walltime_benchmarks, creator)?;
+        std::fs::write(&results_file, serde_json::to_string(&walltime_results)?)?;
+        info!("Results written to {results_file:?}");
+    }
+
+    Ok(())
+}

go-runner/src/main.rs

@@ -0,0 +1,15 @@
+use go_runner::cli::Cli;
+use std::path::Path;
+
+fn main() -> anyhow::Result<()> {
+    env_logger::builder()
+        .parse_env("CODSPEED_LOG")
+        .filter_module("handlebars", log::LevelFilter::Off)
+        .format_timestamp(None)
+        .init();
+
+    let cli = Cli::parse();
+    go_runner::run_benchmarks(Path::new("."), &cli.bench)?;
+
+    Ok(())
+}