Add tool checking and support for all compilable languages

Author: seuros

builder_test.go

@@ -16,8 +16,9 @@ func TestBuilderFactory(t *testing.T) {
 
 	// Test that all expected builders are registered
 	builders := factory.ListBuilders()
-	if len(builders) != 5 {
-		t.Errorf("Expected 5 builders, got %d", len(builders))
+	expectedCount := 11 // 5 original + 3 new specific + 3 generic language builders
+	if len(builders) != expectedCount {
+		t.Errorf("Expected %d builders, got %d", expectedCount, len(builders))
 	}
 
 	// Test builder detection for each type

cargo_builder.go

@@ -24,6 +24,25 @@ func (b *CargoBuilder) Name() string {
 	return "Cargo"
 }
 
+// RequiredTools returns the tools needed for Cargo builds
+func (b *CargoBuilder) RequiredTools() []ToolRequirement {
+	return []ToolRequirement{
+		{
+			Name:    "cargo",
+			Purpose: "Rust package manager and build tool",
+		},
+		{
+			Name:    "rustc",
+			Purpose: "Rust compiler",
+		},
+	}
+}
+
+// CheckTools verifies that Cargo and Rust toolchain are available
+func (b *CargoBuilder) CheckTools() error {
+	return CheckRequiredTools(b.RequiredTools())
+}
+
 // CanBuild checks if this builder can handle the extension file
 func (b *CargoBuilder) CanBuild(extensionFile string) bool {
 	return MatchesPattern(extensionFile, `Cargo\.toml$`)

cmake_builder.go

@@ -25,6 +25,32 @@ func (b *CmakeBuilder) Name() string {
 	return "CMake"
 }
 
+// RequiredTools returns the tools needed for CMake builds
+func (b *CmakeBuilder) RequiredTools() []ToolRequirement {
+	return []ToolRequirement{
+		{
+			Name:    "cmake",
+			Purpose: "CMake build system generator",
+		},
+		{
+			Name:         "gcc",
+			Alternatives: []string{"clang", "cl"},
+			Purpose:      "C/C++ compiler",
+		},
+		{
+			Name:         "make",
+			Alternatives: []string{"gmake", "ninja", "nmake"},
+			Optional:     true,
+			Purpose:      "Build backend (CMake auto-detects if not specified)",
+		},
+	}
+}
+
+// CheckTools verifies that CMake and build tools are available
+func (b *CmakeBuilder) CheckTools() error {
+	return CheckRequiredTools(b.RequiredTools())
+}
+
 // CanBuild checks if this builder can handle the extension file
 func (b *CmakeBuilder) CanBuild(extensionFile string) bool {
 	return MatchesPattern(extensionFile, `CMakeLists\.txt$`)

configure_builder.go

@@ -18,6 +18,32 @@ func (b *ConfigureBuilder) Name() string {
 	return "Configure"
 }
 
+// RequiredTools returns the tools needed for configure-based builds
+func (b *ConfigureBuilder) RequiredTools() []ToolRequirement {
+	return []ToolRequirement{
+		{
+			Name:         "sh",
+			Alternatives: []string{"bash", "dash"},
+			Purpose:      "Shell to execute configure script",
+		},
+		{
+			Name:         "gcc",
+			Alternatives: []string{"clang", "cc"},
+			Purpose:      "C/C++ compiler",
+		},
+		{
+			Name:         "make",
+			Alternatives: []string{"gmake"},
+			Purpose:      "Build automation tool",
+		},
+	}
+}
+
+// CheckTools verifies that shell and make are available
+func (b *ConfigureBuilder) CheckTools() error {
+	return CheckRequiredTools(b.RequiredTools())
+}
+
 // CanBuild checks if this builder can handle the extension file
 func (b *ConfigureBuilder) CanBuild(extensionFile string) bool {
 	return MatchesPattern(extensionFile, `configure$`) || MatchesPattern(extensionFile, `configure\.sh$`)

extconf_builder.go

@@ -18,6 +18,31 @@ func (b *ExtConfBuilder) Name() string {
 	return "ExtConf"
 }
 
+// RequiredTools returns the tools needed for extconf.rb builds
+func (b *ExtConfBuilder) RequiredTools() []ToolRequirement {
+	return []ToolRequirement{
+		{
+			Name:    "ruby",
+			Purpose: "Ruby interpreter for extconf.rb",
+		},
+		{
+			Name:         "gcc",
+			Alternatives: []string{"clang", "cc", "cl"},
+			Purpose:      "C/C++ compiler for native extensions",
+		},
+		{
+			Name:         "make",
+			Alternatives: []string{"gmake", "nmake"},
+			Purpose:      "Build automation tool",
+		},
+	}
+}
+
+// CheckTools verifies that Ruby and C compiler are available
+func (b *ExtConfBuilder) CheckTools() error {
+	return CheckRequiredTools(b.RequiredTools())
+}
+
 // CanBuild checks if this builder can handle the extension file
 func (b *ExtConfBuilder) CanBuild(extensionFile string) bool {
 	return MatchesPattern(extensionFile, `extconf\.rb$`)

factory.go

@@ -49,22 +49,48 @@ type BuilderFactory struct {
 // NewBuilderFactory creates a factory with all standard builders registered.
 //
 // The standard builders are registered in this order:
-//  1. ExtConfBuilder - extconf.rb files
-//  2. ConfigureBuilder - configure scripts
+//
+// Traditional Ruby builders:
+//  1. ExtConfBuilder - extconf.rb files (C/C++)
+//  2. ConfigureBuilder - configure scripts (autotools)
 //  3. RakeBuilder - Rakefile and mkrf_conf.rb
-//  4. CmakeBuilder - CMakeLists.txt
-//  5. CargoBuilder - Cargo.toml
+//
+// Modern build systems:
+//  4. CMakeBuilder - CMakeLists.txt
+//  5. CargoBuilder - Cargo.toml (Rust)
+//  6. MakefileBuilder - Plain Makefile
+//  7. GoBuilder - Go with CGO
+//  8. JavaBuilder - Java/JRuby extensions
+//
+// Modern languages (generic builders):
+//  9. CrystalBuilder - Crystal language
+//
+// 10. ZigBuilder - Zig language
+// 11. SwiftBuilder - Swift language
 //
 // This is the recommended way to create a BuilderFactory for most use cases.
+// Builders are checked in registration order, so more specific builders
+// should be registered first.
 func NewBuilderFactory() *BuilderFactory {
 	factory := &BuilderFactory{}
 
 	// Register all standard builders in priority order
+	// Traditional Ruby builders first (most common)
 	factory.Register(&ExtConfBuilder{})
 	factory.Register(&ConfigureBuilder{})
 	factory.Register(&RakeBuilder{})
+
+	// Modern build systems
 	factory.Register(&CmakeBuilder{})
 	factory.Register(&CargoBuilder{})
+	factory.Register(&MakefileBuilder{})
+	factory.Register(&GoBuilder{})
+	factory.Register(&JavaBuilder{})
+
+	// Modern languages via generic builders
+	factory.Register(NewCrystalBuilder())
+	factory.Register(NewZigBuilder())
+	factory.Register(NewSwiftBuilder())
 
 	return factory
 }