feat: add support for previously unsupported error (#11)

Author: seuros

extconf_builder.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 )
@@ -104,12 +105,16 @@ func (b *ExtConfBuilder) runExtConf(ctx context.Context, config *BuildConfig, ex
 	}
 
 	if err != nil {
+		// Parse output for missing dependencies
+		result.MissingDependencies = b.parseLoadErrors(result.Output)
 		return BuildError("ExtConf", result.Output, err)
 	}
 
 	// Verify Makefile was created
 	makefilePath := filepath.Join(extensionDir, "Makefile")
 	if _, err := os.Stat(makefilePath); os.IsNotExist(err) {
+		// Parse output for missing dependencies even when Makefile wasn't generated
+		result.MissingDependencies = b.parseLoadErrors(result.Output)
 		return BuildError("ExtConf", result.Output, fmt.Errorf("makefile not generated"))
 	}
 
@@ -229,3 +234,58 @@ func (b *ExtConfBuilder) getMakeProgram() string {
 		return "make"
 	}
 }
+
+// parseLoadErrors parses build output for missing dependencies.
+// It recognizes common Ruby error patterns:
+//   - "cannot load such file -- gem_name"
+//   - "Could not find 'gem_name' (~> 1.0)"
+//   - "Gem::MissingSpecVersionError: gem_name requires version ~> 1.0"
+//   - "LoadError: cannot load such file -- gem_name/subpath"
+func (b *ExtConfBuilder) parseLoadErrors(output []string) []MissingDependency {
+	var deps []MissingDependency
+	seen := make(map[string]bool)
+
+	// Regex patterns for different error formats
+	patterns := []*regexp.Regexp{
+		// "cannot load such file -- mini_portile2" or "cannot load such file -- mini_portile2/version"
+		regexp.MustCompile(`cannot load such file -- ([a-zA-Z0-9_-]+)`),
+		// "Could not find 'mini_portile2' (~> 2.8.2)"
+		regexp.MustCompile(`Could not find '([^']+)'(?: \(([^)]+)\))?`),
+		// "Gem::MissingSpecVersionError: mini_portile2 requires ~> 2.8.2"
+		regexp.MustCompile(`Gem::MissingSpec(?:Version)?Error:?\s*([a-zA-Z0-9_-]+)(?:\s+requires?\s+(.+))?`),
+		// "Bundler could not find compatible versions for gem \"mini_portile2\":"
+		regexp.MustCompile(`compatible versions for gem "([^"]+)"`),
+		// "mini_portile2 (~> 2.8.2) was resolved to 2.8.2"
+		regexp.MustCompile(`^([a-zA-Z0-9_-]+) \(([^)]+)\) was resolved`),
+	}
+
+	for _, line := range output {
+		for i, re := range patterns {
+			matches := re.FindStringSubmatch(line)
+			if matches == nil {
+				continue
+			}
+
+			name := matches[1]
+			if seen[name] {
+				continue
+			}
+			seen[name] = true
+
+			dep := MissingDependency{Name: name}
+
+			// Extract version constraint if present
+			if i == 1 && len(matches) > 2 && matches[2] != "" {
+				dep.Constraint = matches[2]
+			} else if i == 2 && len(matches) > 2 && matches[2] != "" {
+				dep.Constraint = strings.TrimSpace(matches[2])
+			} else if i == 4 && len(matches) > 2 {
+				dep.Constraint = matches[2]
+			}
+
+			deps = append(deps, dep)
+		}
+	}
+
+	return deps
+}

rake_builder.go

@@ -294,7 +294,7 @@ func (b *RakeBuilder) findBuiltExtensions(extensionDir string) ([]string, error)
 }
 
 // ensureRakeAvailable verifies that rake can be executed either directly or via RubyGems.
-func (b *RakeBuilder) ensureRakeAvailable(ctx context.Context, config *BuildConfig) ([]string, error) {
+func (b *RakeBuilder) ensureRakeAvailable(ctx context.Context, config *BuildConfig) ([]MissingDependency, error) {
 	if _, err := execLookPath("rake"); err == nil {
 		return nil, nil
 	}
@@ -336,7 +336,7 @@ func (b *RakeBuilder) ensureRakeAvailable(ctx context.Context, config *BuildConf
 	if err := cmd.Run(); err != nil {
 		var exitErr *exec.ExitError
 		if errors.As(err, &exitErr) {
-			return []string{"rake"}, fmt.Errorf("rake not found")
+			return []MissingDependency{{Name: "rake"}}, fmt.Errorf("rake not found")
 		}
 		return nil, fmt.Errorf("failed to verify rake availability: %w", err)
 	}

rake_builder_test.go

@@ -109,7 +109,7 @@ func TestEnsureRakeAvailableMissingRake(t *testing.T) {
 		t.Fatalf("expected rake not found error, got %v", err)
 	}
 
-	expectedMissing := []string{"rake"}
+	expectedMissing := []MissingDependency{{Name: "rake"}}
 	if !reflect.DeepEqual(missing, expectedMissing) {
 		t.Fatalf("expected missing dependencies %v, got %v", expectedMissing, missing)
 	}

types.go

@@ -2,6 +2,12 @@ package rubyext
 
 import "context"
 
+// MissingDependency represents a build-time dependency that was not found.
+type MissingDependency struct {
+	Name       string // Gem name (e.g., "mini_portile2")
+	Constraint string // Version constraint if known (e.g., "~> 2.8.2"), empty if unknown
+}
+
 // BuildResult contains the output and status of a build operation.
 //
 // After a build completes, this structure provides:
@@ -10,11 +16,11 @@ import "context"
 //   - Extensions list of compiled extension files (.so/.bundle/.dll)
 //   - Error information if the build failed
 type BuildResult struct {
-	Success             bool     // True if build completed successfully
-	Output              []string // Lines of output from the build process
-	Extensions          []string // Paths to built extension files
-	Error               error    // Error if build failed, nil otherwise
-	MissingDependencies []string // Names of build-time dependencies that were missing
+	Success             bool                // True if build completed successfully
+	Output              []string            // Lines of output from the build process
+	Extensions          []string            // Paths to built extension files
+	Error               error               // Error if build failed, nil otherwise
+	MissingDependencies []MissingDependency // Build-time dependencies that were missing
 }
 
 // BuildConfig contains configuration for the build process.