feat: many features, check TODO.md

cmd/benchmark/main.go

@@ -0,0 +1,145 @@
+// Package main provides a CLI for running gibidify benchmarks.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+
+	"github.com/ivuorinen/gibidify/benchmark"
+	"github.com/ivuorinen/gibidify/utils"
+)
+
+var (
+	sourceDir       = flag.String("source", "", "Source directory to benchmark (uses temp files if empty)")
+	benchmarkType   = flag.String("type", "all", "Benchmark type: all, collection, processing, concurrency, format")
+	format          = flag.String("format", "json", "Output format for processing benchmarks")
+	concurrency     = flag.Int("concurrency", runtime.NumCPU(), "Concurrency level for processing benchmarks")
+	concurrencyList = flag.String("concurrency-list", "1,2,4,8", "Comma-separated list of concurrency levels")
+	formatList      = flag.String("format-list", "json,yaml,markdown", "Comma-separated list of formats")
+	numFiles        = flag.Int("files", 100, "Number of files to create for benchmarks")
+)
+
+func main() {
+	flag.Parse()
+
+	if err := runBenchmarks(); err != nil {
+		fmt.Fprintf(os.Stderr, "Benchmark failed: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func runBenchmarks() error {
+	fmt.Printf("Running gibidify benchmarks...\n")
+	fmt.Printf("Source: %s\n", getSourceDescription())
+	fmt.Printf("Type: %s\n", *benchmarkType)
+	fmt.Printf("CPU cores: %d\n", runtime.NumCPU())
+	fmt.Println()
+
+	switch *benchmarkType {
+	case "all":
+		return benchmark.RunAllBenchmarks(*sourceDir)
+	case "collection":
+		return runCollectionBenchmark()
+	case "processing":
+		return runProcessingBenchmark()
+	case "concurrency":
+		return runConcurrencyBenchmark()
+	case "format":
+		return runFormatBenchmark()
+	default:
+		return utils.NewValidationError(utils.CodeValidationFormat, "invalid benchmark type: "+*benchmarkType)
+	}
+}
+
+func runCollectionBenchmark() error {
+	fmt.Println("Running file collection benchmark...")
+	result, err := benchmark.FileCollectionBenchmark(*sourceDir, *numFiles)
+	if err != nil {
+		return utils.WrapError(err, utils.ErrorTypeProcessing, utils.CodeProcessingCollection, "file collection benchmark failed")
+	}
+	benchmark.PrintBenchmarkResult(result)
+	return nil
+}
+
+func runProcessingBenchmark() error {
+	fmt.Printf("Running file processing benchmark (format: %s, concurrency: %d)...\n", *format, *concurrency)
+	result, err := benchmark.FileProcessingBenchmark(*sourceDir, *format, *concurrency)
+	if err != nil {
+		return utils.WrapError(err, utils.ErrorTypeProcessing, utils.CodeProcessingCollection, "file processing benchmark failed")
+	}
+	benchmark.PrintBenchmarkResult(result)
+	return nil
+}
+
+func runConcurrencyBenchmark() error {
+	concurrencyLevels, err := parseConcurrencyList(*concurrencyList)
+	if err != nil {
+		return utils.WrapError(err, utils.ErrorTypeValidation, utils.CodeValidationFormat, "invalid concurrency list")
+	}
+
+	fmt.Printf("Running concurrency benchmark (format: %s, levels: %v)...\n", *format, concurrencyLevels)
+	suite, err := benchmark.ConcurrencyBenchmark(*sourceDir, *format, concurrencyLevels)
+	if err != nil {
+		return utils.WrapError(err, utils.ErrorTypeProcessing, utils.CodeProcessingCollection, "concurrency benchmark failed")
+	}
+	benchmark.PrintBenchmarkSuite(suite)
+	return nil
+}
+
+func runFormatBenchmark() error {
+	formats := parseFormatList(*formatList)
+	fmt.Printf("Running format benchmark (formats: %v)...\n", formats)
+	suite, err := benchmark.FormatBenchmark(*sourceDir, formats)
+	if err != nil {
+		return utils.WrapError(err, utils.ErrorTypeProcessing, utils.CodeProcessingCollection, "format benchmark failed")
+	}
+	benchmark.PrintBenchmarkSuite(suite)
+	return nil
+}
+
+func getSourceDescription() string {
+	if *sourceDir == "" {
+		return fmt.Sprintf("temporary files (%d files)", *numFiles)
+	}
+	return *sourceDir
+}
+
+func parseConcurrencyList(list string) ([]int, error) {
+	parts := strings.Split(list, ",")
+	levels := make([]int, 0, len(parts))
+
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		var level int
+		if _, err := fmt.Sscanf(part, "%d", &level); err != nil {
+			return nil, utils.WrapErrorf(err, utils.ErrorTypeValidation, utils.CodeValidationFormat, "invalid concurrency level: %s", part)
+		}
+		if level <= 0 {
+			return nil, utils.NewValidationError(utils.CodeValidationFormat, "concurrency level must be positive: "+part)
+		}
+		levels = append(levels, level)
+	}
+
+	if len(levels) == 0 {
+		return nil, utils.NewValidationError(utils.CodeValidationFormat, "no valid concurrency levels found")
+	}
+
+	return levels, nil
+}
+
+func parseFormatList(list string) []string {
+	parts := strings.Split(list, ",")
+	formats := make([]string, 0, len(parts))
+
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			formats = append(formats, part)
+		}
+	}
+
+	return formats
+}