Refactor #1

Author: blewis12

tools/sync-module-dependencies/ReadMe.md

@@ -0,0 +1,9 @@
+
+# TODO
+
+* Refactor code so that it is as simple and concise as possible.
+* Think about what would happen if we added a different module type
+* Add some basic tests? Not sure what to test there
+* Add a github action that checks if the output of replace generation changes anything in the go.mod file
+  * Could we also add a pre-commit hook for that? 
+* Fill out this readme

tools/sync-module-dependencies/cleanup.go

@@ -1,6 +1,6 @@
 package main
 
-//go:generate go run ./generate-replaces.go
-//go:generate go run ./apply-replaces.go
-//go:generate go run ./tidy-modules.go
-//go:generate go run ./cleanup.go
+//go:generate go run ./internal/generate-replaces.go
+//go:generate go run ./internal/apply-replaces.go
+//go:generate go run ./internal/tidy-modules.go
+//go:generate go run ./internal/cleanup.go

tools/sync-module-dependencies/generate-replaces.go

@@ -5,86 +5,98 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"path/filepath"
 	"strings"
 
-	"github.com/grafana/replace-generator/types"
-	"gopkg.in/yaml.v3"
+	"github.com/grafana/replace-generator/internal/files"
+	"github.com/grafana/replace-generator/internal/types"
 )
 
 func main() {
-	scriptDir, err := os.Getwd()
-	if err != nil {
-		log.Fatalf("Failed to get working directory: %v", err)
-	}
-
-	projectRoot, err := filepath.Abs(filepath.Join(scriptDir, "..", ".."))
-	if err != nil {
-		log.Fatalf("Failed to resolve project root: %v", err)
-	}
+	fileHelper := files.GetFileHelper()
 
-	replacesPath := filepath.Join(projectRoot, "dependency-replacements.yaml")
-	var projectReplaces types.ProjectReplaces
-	data, err := os.ReadFile(replacesPath)
+	projectReplaces, err := fileHelper.LoadProjectReplaces()
 	if err != nil {
-		log.Fatalf("Failed to read dependency-replacements.yaml: %v", err)
-	}
-
-	if err := yaml.Unmarshal(data, &projectReplaces); err != nil {
-		log.Fatalf("Failed to parse dependency-replacements.yaml: %v", err)
+		log.Fatalf("Failed to load project replaces: %v", err)
 	}
 
 	for _, module := range projectReplaces.Modules {
-		if err := applyReplacesToModule(scriptDir, projectRoot, module); err != nil {
+		if err := applyReplacesToModule(fileHelper, module); err != nil {
 			log.Fatalf("Failed to apply replaces to module %q: %v", module.Name, err)
 		}
+		log.Printf("Updated %s", module.Path)
 	}
 }
 
-func applyReplacesToModule(scriptDir string, projectRoot string, module types.Module) error {
-	targetPath := filepath.Join(projectRoot, module.Path)
-
-	replacesPath := filepath.Join(scriptDir, module.OutputFile)
+func applyReplacesToModule(dirs *files.FileHelper, module types.Module) error {
+	targetPath := dirs.ModuleTargetPath(module.Path)
+	replacesPath := dirs.ModuleOutputPath(module.OutputFile)
 
 	replacesContent, err := os.ReadFile(replacesPath)
 	if err != nil {
 		return fmt.Errorf("read replaces file %s: %w", replacesPath, err)
 	}
 
-	content, err := os.ReadFile(targetPath)
+	targetContent, err := os.ReadFile(targetPath)
 	if err != nil {
 		return fmt.Errorf("read target file %s: %w", targetPath, err)
 	}
 
-	var startMarker, endMarker string
-	switch module.FileType {
-	case "mod":
-		// Go mod files use // comments
-		startMarker = "// BEGIN GENERATED REPLACES - DO NOT EDIT"
-		endMarker = "// END GENERATED REPLACES"
-	default:
-		return fmt.Errorf("unknown file_type %q for module %q (expected 'mod')", module.FileType, module.Name)
+	startMarker, endMarker, err := getMarkers(module.FileType)
+	if err != nil {
+		return fmt.Errorf("get markers for file type %q: %w", module.FileType, err)
 	}
 
-	contentStr := string(content)
-	hasMarkers := hasMarkers(contentStr, startMarker, endMarker)
+	newContent := prepareContent(string(targetContent), string(replacesContent), startMarker, endMarker)
+
+	if err := os.WriteFile(targetPath, []byte(newContent), 0o644); err != nil {
+		return fmt.Errorf("write target file %s: %w", targetPath, err)
+	}
+
+	return nil
+}
+
+func prepareContent(targetContent, replacesContent, startMarker, endMarker string) string {
+	markers := hasMarkers(targetContent, startMarker, endMarker)
 
 	var newContent string
-	if hasMarkers {
-		newContent = removeBetweenMarkers(contentStr, startMarker, endMarker)
+	if markers {
+		newContent = removeBetweenMarkers(targetContent, startMarker, endMarker)
 	} else {
-		// No markers found, use original content
-		newContent = contentStr
+		newContent = targetContent
 	}
 
-	newContent = strings.TrimRight(newContent, "\n") + "\n" + string(replacesContent)
+	return strings.TrimRight(newContent, "\n") + "\n" + replacesContent
+}
 
-	if err := os.WriteFile(targetPath, []byte(newContent), 0o644); err != nil {
-		return fmt.Errorf("write target file %s: %w", targetPath, err)
+func getMarkers(fileType string) (startMarker, endMarker string, err error) {
+	switch fileType {
+	case "mod":
+		// Go mod files use // comments
+		return "// BEGIN GENERATED REPLACES - DO NOT EDIT", "// END GENERATED REPLACES", nil
+	default:
+		return "", "", fmt.Errorf("unknown file_type %q", fileType)
 	}
+}
 
-	log.Printf("✅ Updated %s", targetPath)
-	return nil
+func hasMarkers(content, startMarker, endMarker string) bool {
+	startMarkerTrimmed := strings.TrimSpace(startMarker)
+	endMarkerTrimmed := strings.TrimSpace(endMarker)
+
+	hasStart := false
+	hasEnd := false
+
+	scanner := bufio.NewScanner(strings.NewReader(content))
+	for scanner.Scan() {
+		trimmedLine := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(trimmedLine, startMarkerTrimmed) {
+			hasStart = true
+		}
+		if trimmedLine == endMarkerTrimmed {
+			hasEnd = true
+		}
+	}
+
+	return hasStart && hasEnd
 }
 
 func removeBetweenMarkers(content, startMarker, endMarker string) string {
@@ -115,30 +127,5 @@ func removeBetweenMarkers(content, startMarker, endMarker string) string {
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
-		log.Printf("Warning: error scanning content: %v", err)
-	}
-
 	return result.String()
 }
-
-func hasMarkers(content, startMarker, endMarker string) bool {
-	startMarkerTrimmed := strings.TrimSpace(startMarker)
-	endMarkerTrimmed := strings.TrimSpace(endMarker)
-
-	hasStart := false
-	hasEnd := false
-
-	scanner := bufio.NewScanner(strings.NewReader(content))
-	for scanner.Scan() {
-		trimmedLine := strings.TrimSpace(scanner.Text())
-		if strings.HasPrefix(trimmedLine, startMarkerTrimmed) {
-			hasStart = true
-		}
-		if trimmedLine == endMarkerTrimmed {
-			hasEnd = true
-		}
-	}
-
-	return hasStart && hasEnd
-}

tools/sync-module-dependencies/generate.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/grafana/replace-generator/internal/files"
+)
+
+func main() {
+	fileHelper := files.GetFileHelper()
+
+	if err := cleanupOutputFiles(fileHelper.ScriptDir); err != nil {
+		log.Fatalf("Failed to cleanup output files: %v", err)
+	}
+}
+
+// The previous steps in the generation pipeline output some temporary .txt files, cleanupOutputFiles removes these files
+func cleanupOutputFiles(scriptDir string) error {
+	entries, err := os.ReadDir(scriptDir)
+	if err != nil {
+		return fmt.Errorf("read directory: %w", err)
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		name := entry.Name()
+		if !strings.HasSuffix(strings.ToLower(name), ".txt") {
+			continue
+		}
+
+		filePath := filepath.Join(scriptDir, name)
+		if err := os.Remove(filePath); err != nil {
+			log.Printf("Failed to remove %s: %v", name, err)
+			continue
+		}
+	}
+
+	return nil
+}