feat(internal/postprocessing): add replace and replaceRegex functions (#6412)

Add the replace and replaceRegex functions to the postprocessing
package. They perform exact string and regex replacements in files and
return an error if the target text is not found.

Fixes #6297

Author: yangyzs

internal/postprocessing/fileops.go

@@ -16,11 +16,19 @@
 package postprocessing
 
 import (
+	"bytes"
+	"errors"
+	"fmt"
 	"os"
+	"regexp"
+	"strings"
 
 	"github.com/googleapis/librarian/internal/filesystem"
 )
 
+// errTextNotFound is returned when the target text or pattern is not found in the file.
+var errTextNotFound = errors.New("text not found")
+
 // CopyFile copies a single file from the src path to the dst path.
 // It acts as a wrapper around filesystem.CopyFile to provide a unified
 // interface for all postprocessing file operations.
@@ -32,3 +40,40 @@ func CopyFile(src, dst string) error {
 func RemoveFile(path string) error {
 	return os.Remove(path)
 }
+
+// Replace finds and replaces exact text in a file.
+// It returns an error if the target file does not exist or if the text is not found.
+func Replace(path, original, replacement string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	oldBytes := []byte(original)
+	if !bytes.Contains(content, oldBytes) {
+		return fmt.Errorf("%w: %q in file %s", errTextNotFound, original, path)
+	}
+	newContent := bytes.ReplaceAll(content, oldBytes, []byte(replacement))
+	return os.WriteFile(path, newContent, 0644)
+}
+
+// ReplaceRegex finds and replaces text in a file using a regular expression.
+// It returns an error if the target file does not exist or if the pattern matches no text.
+func ReplaceRegex(path, pattern, replacement string) error {
+	// Default to multiline mode so ^ and $ match per-line.
+	if !strings.HasPrefix(pattern, "(?") {
+		pattern = "(?m)" + pattern
+	}
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return err
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	if !re.Match(content) {
+		return fmt.Errorf("%w: pattern %q in file %s", errTextNotFound, pattern, path)
+	}
+	newContent := re.ReplaceAll(content, []byte(replacement))
+	return os.WriteFile(path, newContent, 0644)
+}

internal/postprocessing/fileops_test.go

@@ -93,3 +93,150 @@ func TestRemoveFile_Error(t *testing.T) {
 		t.Errorf("RemoveFile() error = %v, wantErr %v", err, syscall.ENOTEMPTY)
 	}
 }
+
+func TestReplace(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "test.txt")
+	content := "Hello World"
+	original := "World"
+	replacement := "Go"
+	want := "Hello Go"
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := Replace(path, original, replacement); err != nil {
+		t.Fatal(err)
+	}
+	gotBytes, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := string(gotBytes)
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
+	}
+}
+
+func TestReplaceRegex(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name        string
+		content     string
+		pattern     string
+		replacement string
+		want        string
+	}{
+		{
+			name:        "simple replacement",
+			content:     "Hello World",
+			pattern:     "World",
+			replacement: "Go",
+			want:        "Hello Go",
+		},
+		{
+			name:        "regex replacement",
+			content:     "Hello 123 World",
+			pattern:     `\d+`,
+			replacement: "Number",
+			want:        "Hello Number World",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			dir := t.TempDir()
+			path := filepath.Join(dir, "test.txt")
+			if err := os.WriteFile(path, []byte(test.content), 0644); err != nil {
+				t.Fatal(err)
+			}
+			if err := ReplaceRegex(path, test.pattern, test.replacement); err != nil {
+				t.Fatal(err)
+			}
+			gotBytes, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := string(gotBytes)
+			if diff := cmp.Diff(test.want, got); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestReplace_Error(t *testing.T) {
+	for _, test := range []struct {
+		name        string
+		content     string
+		original    string
+		replacement string
+		wantErr     error
+	}{
+		{
+			name:        "file does not exist",
+			original:    "old",
+			replacement: "new",
+			wantErr:     fs.ErrNotExist,
+		},
+		{
+			name:        "text not found",
+			content:     "Hello World",
+			original:    "Apple",
+			replacement: "Go",
+			wantErr:     errTextNotFound,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			path := filepath.Join(dir, "nonexistent.txt")
+			if test.content != "" {
+				path = filepath.Join(dir, "test.txt")
+				if err := os.WriteFile(path, []byte(test.content), 0644); err != nil {
+					t.Fatal(err)
+				}
+			}
+			err := Replace(path, test.original, test.replacement)
+			if !errors.Is(err, test.wantErr) {
+				t.Errorf("Replace() returned unexpected error: got %v, want %v", err, test.wantErr)
+			}
+		})
+	}
+}
+
+func TestReplaceRegex_Error(t *testing.T) {
+	for _, test := range []struct {
+		name        string
+		content     string
+		pattern     string
+		replacement string
+		wantErr     error
+	}{
+		{
+			name:        "file does not exist",
+			pattern:     "old",
+			replacement: "new",
+			wantErr:     fs.ErrNotExist,
+		},
+		{
+			name:        "pattern not found",
+			content:     "Hello World",
+			pattern:     `\d+`,
+			replacement: "Number",
+			wantErr:     errTextNotFound,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			path := filepath.Join(dir, "nonexistent.txt")
+			if test.content != "" {
+				path = filepath.Join(dir, "test.txt")
+				if err := os.WriteFile(path, []byte(test.content), 0644); err != nil {
+					t.Fatal(err)
+				}
+			}
+			err := ReplaceRegex(path, test.pattern, test.replacement)
+			if !errors.Is(err, test.wantErr) {
+				t.Errorf("ReplaceRegex() returned unexpected error: got %v, want %v", err, test.wantErr)
+			}
+		})
+	}
+}