feat: generate codspeed_runner.go to call benchmarks

Author: not-matthias

go-runner/src/builder/template.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+    "io"
+    "time"
+    "reflect"
+    codspeed "github.com/CodSpeedHQ/codspeed-go/compat/testing"
+    codspeed_testing "github.com/CodSpeedHQ/codspeed-go/testing/testing"
+
+    // Import parent package containing the benchmarks
+{{#each benchmarks}}
+    {{import_alias}} "{{module_path}}"
+{{/each}}
+)
+
+type BenchmarkEntry struct {
+    Name string
+    Func func(b *codspeed.B)
+}
+
+type corpusEntry = struct {
+    Parent     string
+    Path       string
+    Data       []byte
+    Values     []any
+    Generation int
+    IsSeed     bool
+}
+
+type simpleDeps struct{}
+
+func (d simpleDeps) ImportPath() string { return "" }
+func (d simpleDeps) MatchString(pat, str string) (bool, error) { return true, nil }
+func (d simpleDeps) SetPanicOnExit0(bool) {}
+func (d simpleDeps) StartCPUProfile(io.Writer) error { return nil }
+func (d simpleDeps) StopCPUProfile() {}
+func (d simpleDeps) StartTestLog(io.Writer) {}
+func (d simpleDeps) StopTestLog() error { return nil }
+func (d simpleDeps) WriteProfileTo(string, io.Writer, int) error { return nil }
+
+func (d simpleDeps) CoordinateFuzzing(
+    fuzzTime time.Duration,
+    fuzzN int64,
+    minimizeTime time.Duration,
+    minimizeN int64,
+    parallel int,
+    corpus []corpusEntry,
+    types []reflect.Type,
+    corpusDir,
+    cacheDir string,
+) error {
+    return nil
+}
+func (d simpleDeps) RunFuzzWorker(fn func(corpusEntry) error) error {
+    return nil
+}
+func (d simpleDeps) ReadCorpus(dir string, types []reflect.Type) ([]corpusEntry, error) {
+    return nil, nil
+}
+func (d simpleDeps) CheckCorpus(vals []any, types []reflect.Type) error {
+    return nil
+}
+func (d simpleDeps) ResetCoverage() {}
+func (d simpleDeps) SnapshotCoverage() {}
+func (d simpleDeps) InitRuntimeCoverage() (mode string, tearDown func(coverprofile string, gocoverdir string) (string, error), snapcov func() float64) {
+    return "", nil, nil
+}
+
+func main() {
+    var tests = []codspeed_testing.InternalTest{}
+    var fuzzTargets = []codspeed_testing.InternalFuzzTarget{}
+    var examples = []codspeed_testing.InternalExample{}
+    var benchmarks = []codspeed_testing.InternalBenchmark{
+{{#each benchmarks}}
+        {"{{name}}", {{qualified_name}}},
+{{/each}}
+    }
+
+    m := codspeed_testing.MainStart(simpleDeps{}, tests, benchmarks, fuzzTargets, examples)
+    m.Run()
+}

go-runner/src/builder/templater.rs

@@ -0,0 +1,89 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use handlebars::Handlebars;
+use serde::{Deserialize, Serialize};
+use tempfile::TempDir;
+
+use crate::builder::{BenchmarkPackage, GoBenchmark};
+use crate::utils;
+use crate::{builder::patcher, prelude::*};
+
+#[derive(Debug, Serialize, Deserialize)]
+struct TemplateData {
+    benchmarks: Vec<GoBenchmark>,
+    module_name: String,
+}
+
+pub fn run(package: &BenchmarkPackage) -> anyhow::Result<(TempDir, PathBuf)> {
+    // 1. Copy the whole module to a build directory
+    let target_dir = TempDir::new()?;
+    std::fs::create_dir_all(&target_dir).context("Failed to create target directory")?;
+    utils::copy_dir_recursively(&package.module.dir, &target_dir)?;
+
+    // Get files that need to be renamed first
+    let files = package
+        .test_go_files
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("No test files found for package: {}", package.name))?;
+
+    // Calculate the relative path from module root to package directory
+    let package_dir = Path::new(&package.dir);
+    let module_dir = Path::new(&package.module.dir);
+    let relative_package_path = package_dir.strip_prefix(module_dir).context(format!(
+        "Package dir {:?} is not within module dir {:?}",
+        package.dir, package.module.dir
+    ))?;
+    debug!("Relative package path: {relative_package_path:?}");
+
+    // 2. Find benchmark files and patch their imports
+    let files_to_patch = package
+        .benchmarks
+        .iter()
+        .map(|bench| target_dir.path().join(&bench.file_path))
+        .collect::<Vec<_>>();
+    patcher::patch_imports(&target_dir, files_to_patch)?;
+
+    // 3. Rename the _test.go files to _codspeed.go
+    for file in files {
+        let old_path = target_dir.path().join(relative_package_path).join(file);
+        let new_path = old_path.with_file_name(
+            old_path
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .replace("_test", "_codspeed"),
+        );
+
+        fs::rename(&old_path, &new_path)
+            .context(format!("Failed to rename {old_path:?} to {new_path:?}"))?;
+    }
+
+    // 4. Generate the codspeed/runner.go file using the template
+    let mut handlebars = Handlebars::new();
+    let template_content = include_str!("template.go");
+    handlebars.register_template_string("main", template_content)?;
+
+    // import <alias> <mod_path>
+    // { "<name>", <qualified_path> },
+    let data = TemplateData {
+        benchmarks: package.benchmarks.clone(),
+        module_name: "codspeed_runner".into(),
+    };
+    let rendered = handlebars.render("main", &data)?;
+
+    let runner_path = target_dir
+        .path()
+        .join(relative_package_path)
+        .join("codspeed/runner.go");
+    fs::create_dir_all(
+        target_dir
+            .path()
+            .join(relative_package_path)
+            .join("codspeed"),
+    )
+    .context("Failed to create codspeed directory")?;
+    fs::write(&runner_path, rendered).context("Failed to write runner.go file")?;
+
+    Ok((target_dir, runner_path))
+}

go-runner/src/utils.rs

@@ -0,0 +1,20 @@
+use std::path::Path;
+use std::{fs, io};
+
+pub fn copy_dir_recursively(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
+    fs::create_dir_all(&dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        if ty.is_dir() {
+            if entry.file_name() == ".git" {
+                continue;
+            }
+
+            copy_dir_recursively(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}