Refactor code processor: enhance replacement logic, improve error handling, and streamline whitespace management

Author: AeonDave

Makefile

@@ -25,14 +25,42 @@ build: increment-version
 .PHONY: increment-version
 increment-version:
 	@echo "Incrementing build version..."
-	@current_version=$$(grep 'Version = ' internal/constants.go | sed 's/.*"\([^"]*\)".*/\1/'); \
-	major=$$(echo $$current_version | cut -d. -f1); \
-	minor=$$(echo $$current_version | cut -d. -f2); \
-	patch=$$(echo $$current_version | cut -d. -f3); \
-	new_patch=$$((patch + 1)); \
-	new_version="$$major.$$minor.$$new_patch"; \
-	echo "Updating version from $$current_version to $$new_version"; \
-	sed -i 's/Version = "[^"]*"/Version = "'$$new_version'"/' internal/constants.go
+	@go run - <<'EOF'
+package main
+
+import (
+    "fmt"
+    "os"
+    "regexp"
+    "strconv"
+)
+
+func main() {
+    const file = "internal/constants.go"
+    data, err := os.ReadFile(file)
+    if err != nil {
+        panic(err)
+    }
+
+    re := regexp.MustCompile(`Version\s*=\s*"(\d+)\.(\d+)\.(\d+)"`)
+    matches := re.FindSubmatch(data)
+    if matches == nil {
+        panic("could not find version in internal/constants.go")
+    }
+
+    major, _ := strconv.Atoi(string(matches[1]))
+    minor, _ := strconv.Atoi(string(matches[2]))
+    patch, _ := strconv.Atoi(string(matches[3]))
+    newVersion := fmt.Sprintf("%d.%d.%d", major, minor, patch+1)
+
+    fmt.Printf("Updating version from %d.%d.%d to %s\n", major, minor, patch, newVersion)
+
+    updated := re.ReplaceAll(data, []byte(fmt.Sprintf(`Version = "%s"`, newVersion)))
+    if err := os.WriteFile(file, updated, 0o644); err != nil {
+        panic(err)
+    }
+}
+EOF
 
 # Build without version increment
 .PHONY: build-no-version
@@ -61,9 +89,9 @@ endif
 
 # Test the tool (create a simple test)
 .PHONY: test
-test: build
-	@echo "Testing goahead build..."
-	@echo "GoAhead built successfully. Use 'goahead -h' for usage help."
+test:
+	@echo "Running unit and integration tests..."
+	go test ./...
 
 # Test as toolexec (requires installation)
 .PHONY: test-toolexec
@@ -100,12 +128,13 @@ help:
 	@echo "Available targets:"
 	@echo "  build         - Build for current platform"
 	@echo "  install       - Install goahead locally"
-	@echo "  test          - Test goahead in standalone mode"
+	@echo "  test          - Run go test ./..."
 	@echo "  test-toolexec - Test goahead as toolexec"
 	@echo "  build-cross   - Cross-compile for multiple platforms"
 	@echo "  clean         - Clean build artifacts"
 	@echo "  setup         - Setup project dependencies"
 	@echo "  help          - Show this help"
-	@echo ""	@echo "Usage after installation:"
+	@echo ""
+	@echo "Usage after installation:"
 	@echo "  go install github.com/AeonDave/goahead@latest"
-	@echo "  go build -toolexec=\"goahead\" main.go"
+	@echo "  go build -toolexec=\"goahead\" ./..."

internal/code_processor.go

@@ -2,6 +2,7 @@ package internal
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"os"
 	"regexp"
@@ -17,6 +18,11 @@ type CodeProcessor struct {
 var (
 	assignmentPattern      = regexp.MustCompile(`^\s*(var\s+\w+(\s+[\w.\[\]]+)?\s*=|[\w.,\s]+\s*:=|[\w.]+\s*=)\s*`)
 	assignmentSplitPattern = regexp.MustCompile(`^(\s*(?:var\s+\w+(?:\s+[\w.\[\]]+)?\s*=|[\w.,\s]+\s*:=|[\w.]+\s*=)\s*)(.*)$`)
+	stringLiteralPattern   = regexp.MustCompile(`""`)
+	numericZeroPattern     = regexp.MustCompile(`\b0\b`)
+	floatZeroPattern       = regexp.MustCompile(`\b0\.0\b`)
+	boolFalsePattern       = regexp.MustCompile(`\bfalse\b`)
+	errNoReplacement       = errors.New("no replacement performed")
 )
 
 func NewCodeProcessor(ctx *ProcessorContext, executor *FunctionExecutor) *CodeProcessor {
@@ -95,59 +101,80 @@ func (cp *CodeProcessor) processCodeLine(line, funcName, argsStr, filePath strin
 		return line, false
 	}
 
-	typeHint := "other"
-	if userFunc, ok := cp.ctx.Functions[funcName]; ok {
-		typeHint = mapOutputType(userFunc.OutputType)
+	typeHint := cp.typeHintFor(funcName, result)
+	formattedResult := formatResultForReplacement(result, typeHint)
+
+	leadingWhitespace, _ := splitLeadingWhitespace(line)
+	newLine, replaced, buildErr := cp.buildReplacementLine(line, leadingWhitespace, funcName, argsStr, formattedResult, typeHint)
+	if buildErr != nil {
+		if errors.Is(buildErr, errNoReplacement) {
+			_, _ = fmt.Fprintf(os.Stderr, "Warning: Could not replace function call for '%s' in line: %s\n", funcName, strings.TrimSpace(line))
+		}
+		return line, false
 	}
 
-	inferred := inferResultKind(result)
-	if typeHint == "other" {
-		typeHint = inferred
+	if replaced {
+		_, _ = fmt.Fprintf(os.Stderr, "[goahead] Replaced in %s: %s(%s) -> %s\n", filePath, funcName, argsStr, result)
+		if verbose {
+			_, _ = fmt.Fprintf(os.Stderr, "  Original: '%s'\n  New: '%s'\n", strings.TrimSpace(line), strings.TrimSpace(newLine))
+		}
 	}
 
-	formattedResult := formatResultForReplacement(result, typeHint)
+	return newLine, replaced
+}
 
-	trimmedLine := strings.TrimSpace(line)
-	leadingWhitespace := ""
-	if len(line) > len(trimmedLine) {
-		leadingWhitespace = line[:len(line)-len(trimmedLine)]
+func splitLeadingWhitespace(line string) (string, string) {
+	trimmed := strings.TrimSpace(line)
+	if len(line) == len(trimmed) {
+		return "", line
 	}
+	return line[:len(line)-len(trimmed)], trimmed
+}
 
-	isAssignment := assignmentPattern.MatchString(line)
+func (cp *CodeProcessor) buildReplacementLine(originalLine, leadingWhitespace, funcName, argsStr, formattedResult, typeHint string) (string, bool, error) {
+	if assignmentPattern.MatchString(originalLine) {
+		return cp.replaceInAssignment(originalLine, funcName, argsStr, formattedResult, typeHint)
+	}
 
-	var newLine string
-	if isAssignment {
-		matches := assignmentSplitPattern.FindStringSubmatch(line)
+	if replacedLine, ok := cp.replaceFunctionCall(originalLine, funcName, argsStr, formattedResult); ok {
+		return replacedLine, true, nil
+	}
 
-		if len(matches) >= 3 {
-			varAssignPart := matches[1]
-			expressionPart := matches[2]
-			replacedExpression := cp.replaceFirstPlaceholder(expressionPart, formattedResult, typeHint)
-			if replacedExpression != expressionPart {
-				newLine = varAssignPart + replacedExpression
-			} else {
-				newLine = varAssignPart + formattedResult
-			}
-		} else {
-			replacement := cp.replaceFunctionCall(line, funcName, argsStr, formattedResult)
-			if replacement == line {
-				_, _ = fmt.Fprintf(os.Stderr, "Warning: Could not replace function call for '%s' in line: %s\n", funcName, strings.TrimSpace(line))
-				return line, false
-			}
-			newLine = replacement
+	newLine := leadingWhitespace + formattedResult
+	return newLine, newLine != originalLine, nil
+}
+
+func (cp *CodeProcessor) replaceInAssignment(originalLine, funcName, argsStr, formattedResult, typeHint string) (string, bool, error) {
+	matches := assignmentSplitPattern.FindStringSubmatch(originalLine)
+	if len(matches) < 3 {
+		replacedLine, ok := cp.replaceFunctionCall(originalLine, funcName, argsStr, formattedResult)
+		if !ok {
+			return "", false, errNoReplacement
 		}
-	} else {
-		newLine = leadingWhitespace + formattedResult
+		return replacedLine, true, nil
 	}
 
-	replaced := newLine != line
+	varAssignPart := matches[1]
+	expressionPart := matches[2]
+
+	replacedExpression, replaced := cp.replaceFirstPlaceholder(expressionPart, formattedResult, typeHint)
 	if replaced {
-		_, _ = fmt.Fprintf(os.Stderr, "[goahead] Replaced in %s: %s(%s) -> %s\n", filePath, funcName, argsStr, result)
-		if verbose {
-			_, _ = fmt.Fprintf(os.Stderr, "  Original: '%s'\n  New: '%s'\n", strings.TrimSpace(line), strings.TrimSpace(newLine))
+		newLine := varAssignPart + replacedExpression
+		return newLine, newLine != originalLine, nil
+	}
+
+	newLine := varAssignPart + formattedResult
+	return newLine, newLine != originalLine, nil
+}
+
+func (cp *CodeProcessor) typeHintFor(funcName, result string) string {
+	if userFunc, ok := cp.ctx.Functions[funcName]; ok {
+		hint := mapOutputType(userFunc.OutputType)
+		if hint != "other" {
+			return hint
 		}
 	}
-	return newLine, replaced
+	return inferResultKind(result)
 }
 
 func (cp *CodeProcessor) writeFile(filePath string, lines []string) error {
@@ -183,98 +210,49 @@ func escapeString(s string) string {
 	return `"` + strings.ReplaceAll(s, `"`, `\"`) + `"`
 }
 
-func (cp *CodeProcessor) replaceFirstPlaceholder(expression, replacement, typeHint string) string {
+func (cp *CodeProcessor) replaceFirstPlaceholder(expression, replacement, typeHint string) (string, bool) {
 	switch typeHint {
 	case "string":
-		re := regexp.MustCompile(`""`)
-		if re.MatchString(expression) {
-			replaced := false
-			return re.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
-		}
-
-	case "int":
-		re := regexp.MustCompile(`\b0\b`)
-		if re.MatchString(expression) {
-			replaced := false
-			return re.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
-		}
-
-	case "uint":
-		re := regexp.MustCompile(`\b0\b`)
-		if re.MatchString(expression) {
-			replaced := false
-			return re.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
-		}
-
+		return replaceFirstMatch(stringLiteralPattern, expression, replacement)
+	case "int", "uint":
+		return replaceFirstMatch(numericZeroPattern, expression, replacement)
 	case "float":
-		re := regexp.MustCompile(`\b0\.0\b`)
-		if re.MatchString(expression) {
-			replaced := false
-			return re.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
-		}
-		reZero := regexp.MustCompile(`\b0\b`)
-		if reZero.MatchString(expression) {
-			replaced := false
-			return reZero.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
+		if updated, ok := replaceFirstMatch(floatZeroPattern, expression, replacement); ok {
+			return updated, true
 		}
-
+		return replaceFirstMatch(numericZeroPattern, expression, replacement)
 	case "bool":
-		re := regexp.MustCompile(`\bfalse\b`)
-		if re.MatchString(expression) {
-			replaced := false
-			return re.ReplaceAllStringFunc(expression, func(match string) string {
-				if !replaced {
-					replaced = true
-					return replacement
-				}
-				return match
-			})
-		}
+		return replaceFirstMatch(boolFalsePattern, expression, replacement)
+	default:
+		return expression, false
 	}
-	return expression
 }
 
-func (cp *CodeProcessor) replaceFunctionCall(line, funcName, argsStr, replacement string) string {
-	updated := line
+func replaceFirstMatch(re *regexp.Regexp, expression, replacement string) (string, bool) {
+	replaced := false
+	updated := re.ReplaceAllStringFunc(expression, func(match string) string {
+		if replaced {
+			return match
+		}
+		replaced = true
+		return replacement
+	})
+	return updated, replaced
+}
+
+func (cp *CodeProcessor) replaceFunctionCall(line, funcName, argsStr, replacement string) (string, bool) {
 	if argsStr != "" {
 		re := regexp.MustCompile(fmt.Sprintf(`%s\(\s*%s\s*\)`, regexp.QuoteMeta(funcName), regexp.QuoteMeta(argsStr)))
-		updated = re.ReplaceAllString(updated, replacement)
+		if re.MatchString(line) {
+			return re.ReplaceAllString(line, replacement), true
+		}
 	}
-	if updated == line {
-		re := regexp.MustCompile(fmt.Sprintf(`%s\([^)]*\)`, regexp.QuoteMeta(funcName)))
-		updated = re.ReplaceAllString(updated, replacement)
+
+	re := regexp.MustCompile(fmt.Sprintf(`%s\([^)]*\)`, regexp.QuoteMeta(funcName)))
+	if re.MatchString(line) {
+		return re.ReplaceAllString(line, replacement), true
 	}
-	return updated
+	return line, false
 }
 
 func mapOutputType(outputType string) string {

internal/constants.go

@@ -1,7 +1,7 @@
 package internal
 
 const (
-	Version           = "1.0.2"
+	Version           = "1.1.0"
 	FunctionMarker    = "//go:ahead functions"
 	CommentPattern    = `^\s*//\s*:([^:]+)(?::(.*))?`
 	ExecutionTemplate = `package main
@@ -37,23 +37,4 @@ var (
 		"/vendor/",
 		"/pkg/mod/",
 	}
-	//SupportedTypes = []string{
-	//	"string",
-	//	"int",
-	//	"int8",
-	//	"int16",
-	//	"int32",
-	//	"int64",
-	//	"uint",
-	//	"uint8",
-	//	"uint16",
-	//	"uint32",
-	//	"uint64",
-	//	"bool",
-	//	"float32",
-	//	"float64",
-	//	"byte",
-	//	"rune",
-	//}
-	//ExcludedPaths = append(GoInstallPaths, SystemPaths...)
 )