feat: add --ignore-pattern flag to generate -watch (#1280)

Co-authored-by: Adrian Hesketh <inbox@adrianhesketh.com>

Author: patrickkdev

cmd/templ/generatecmd/cmd.go

@@ -296,7 +296,7 @@ func (cmd Generate) handleEvents(ctx context.Context, events chan fsnotify.Event
 
 func (cmd *Generate) walkAndWatch(ctx context.Context, events chan fsnotify.Event, errs chan error) {
 	cmd.Log.Debug("Walking directory", slog.String("path", cmd.Args.Path), slog.Bool("devMode", cmd.Args.Watch))
-	if err := watcher.WalkFiles(ctx, cmd.Args.Path, cmd.Args.WatchPattern, events); err != nil {
+	if err := watcher.WalkFiles(ctx, cmd.Args.Path, cmd.Args.WatchPattern, cmd.Args.IgnorePattern, events); err != nil {
 		cmd.Log.Error("WalkFiles failed, exiting", slog.Any("error", err))
 		errs <- FatalError{Err: fmt.Errorf("failed to walk files: %w", err)}
 		return
@@ -306,7 +306,7 @@ func (cmd *Generate) walkAndWatch(ctx context.Context, events chan fsnotify.Even
 		return
 	}
 	cmd.Log.Info("Watching files")
-	rw, err := watcher.Recursive(ctx, cmd.Args.WatchPattern, events, errs)
+	rw, err := watcher.Recursive(ctx, cmd.Args.WatchPattern, cmd.Args.IgnorePattern, events, errs)
 	if err != nil {
 		cmd.Log.Error("Recursive watcher setup failed, exiting", slog.Any("error", err))
 		errs <- FatalError{Err: fmt.Errorf("failed to setup recursive watcher: %w", err)}

cmd/templ/generatecmd/main.go

@@ -37,6 +37,8 @@ Args:
     Set to true to watch the path for changes and regenerate code.
   -watch-pattern <regexp>
     Set the regexp pattern of files that will be watched for changes. (default: '(.+\.go$)|(.+\.templ$)|(.+_templ\.txt$)')
+  -ignore-pattern <regexp>
+    Set the regexp pattern of files to ignore when watching for changes. (default: '')
   -cmd <cmd>
     Set the command to run after generating code.
   -proxy
@@ -89,6 +91,7 @@ func NewArguments(stdout, stderr io.Writer, args []string) (cmdArgs Arguments, l
 	cmd.BoolVar(&cmdArgs.IncludeTimestamp, "include-timestamp", false, "")
 	cmd.BoolVar(&cmdArgs.Watch, "watch", false, "")
 	watchPatternFlag := cmd.String("watch-pattern", defaultWatchPattern, "")
+	ignorePatternFlag := cmd.String("ignore-pattern", "", "")
 	cmd.BoolVar(&cmdArgs.OpenBrowser, "open-browser", true, "")
 	cmd.StringVar(&cmdArgs.Command, "cmd", "", "")
 	cmd.StringVar(&cmdArgs.Proxy, "proxy", "", "")
@@ -115,6 +118,12 @@ func NewArguments(stdout, stderr io.Writer, args []string) (cmdArgs Arguments, l
 	if err != nil {
 		return cmdArgs, log, *helpFlag, fmt.Errorf("invalid watch pattern %q: %w", *watchPatternFlag, err)
 	}
+	if *ignorePatternFlag != "" {
+		cmdArgs.IgnorePattern, err = regexp.Compile(*ignorePatternFlag)
+		if err != nil {
+			return cmdArgs, log, *helpFlag, fmt.Errorf("invalid ignore pattern %q: %w", *ignorePatternFlag, err)
+		}
+	}
 
 	// Default to writing to files unless the stdout flag is set.
 	cmdArgs.FileWriter = FileWriter
@@ -134,6 +143,7 @@ type Arguments struct {
 	Path                            string
 	Watch                           bool
 	WatchPattern                    *regexp.Regexp
+	IgnorePattern                   *regexp.Regexp
 	OpenBrowser                     bool
 	Command                         string
 	ProxyBind                       string

cmd/templ/generatecmd/watcher/watch.go

@@ -16,6 +16,7 @@ import (
 func Recursive(
 	ctx context.Context,
 	watchPattern *regexp.Regexp,
+	ignorePattern *regexp.Regexp,
 	out chan fsnotify.Event,
 	errors chan error,
 ) (w *RecursiveWatcher, err error) {
@@ -24,13 +25,14 @@ func Recursive(
 		return nil, err
 	}
 	w = &RecursiveWatcher{
-		ctx:          ctx,
-		w:            fsnw,
-		WatchPattern: watchPattern,
-		Events:       out,
-		Errors:       errors,
-		timers:       make(map[timerKey]*time.Timer),
-		loopComplete: sync.WaitGroup{},
+		ctx:           ctx,
+		w:             fsnw,
+		WatchPattern:  watchPattern,
+		IgnorePattern: ignorePattern,
+		Events:        out,
+		Errors:        errors,
+		timers:        make(map[timerKey]*time.Timer),
+		loopComplete:  sync.WaitGroup{},
 	}
 	w.loopComplete.Add(1)
 	go func() {
@@ -42,7 +44,7 @@ func Recursive(
 
 // WalkFiles walks the file tree rooted at path, sending a Create event for each
 // file it encounters.
-func WalkFiles(ctx context.Context, rootPath string, watchPattern *regexp.Regexp, out chan fsnotify.Event) (err error) {
+func WalkFiles(ctx context.Context, rootPath string, watchPattern, ignorePattern *regexp.Regexp, out chan fsnotify.Event) (err error) {
 	return fs.WalkDir(os.DirFS(rootPath), ".", func(path string, info os.DirEntry, err error) error {
 		if err != nil {
 			return nil
@@ -57,6 +59,9 @@ func WalkFiles(ctx context.Context, rootPath string, watchPattern *regexp.Regexp
 		if !watchPattern.MatchString(absPath) {
 			return nil
 		}
+		if ignorePattern != nil && ignorePattern.MatchString(absPath) {
+			return nil
+		}
 		out <- fsnotify.Event{
 			Name: absPath,
 			Op:   fsnotify.Create,
@@ -66,14 +71,15 @@ func WalkFiles(ctx context.Context, rootPath string, watchPattern *regexp.Regexp
 }
 
 type RecursiveWatcher struct {
-	ctx          context.Context
-	w            *fsnotify.Watcher
-	WatchPattern *regexp.Regexp
-	Events       chan fsnotify.Event
-	Errors       chan error
-	timerMu      sync.Mutex
-	timers       map[timerKey]*time.Timer
-	loopComplete sync.WaitGroup
+	ctx           context.Context
+	w             *fsnotify.Watcher
+	WatchPattern  *regexp.Regexp
+	IgnorePattern *regexp.Regexp
+	Events        chan fsnotify.Event
+	Errors        chan error
+	timerMu       sync.Mutex
+	timers        map[timerKey]*time.Timer
+	loopComplete  sync.WaitGroup
 }
 
 type timerKey struct {
@@ -114,6 +120,10 @@ func (w *RecursiveWatcher) loop() {
 			if !w.WatchPattern.MatchString(event.Name) {
 				continue
 			}
+			// Skip files that match the ignore pattern.
+			if w.IgnorePattern != nil && w.IgnorePattern.MatchString(event.Name) {
+				continue
+			}
 			tk := timerKeyFromEvent(event)
 			w.timerMu.Lock()
 			t, ok := w.timers[tk]

cmd/templ/generatecmd/watcher/watch_test.go

@@ -18,7 +18,7 @@ func TestWatchDebouncesDuplicates(t *testing.T) {
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 	}
-	rw, err := Recursive(ctx, watchPattern, events, errors)
+	rw, err := Recursive(ctx, watchPattern, nil, events, errors)
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
 	}
@@ -71,7 +71,7 @@ func TestWatchDoesNotDebounceDifferentEvents(t *testing.T) {
 		if err != nil {
 			t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 		}
-		rw, err := Recursive(ctx, watchPattern, events, errors)
+		rw, err := Recursive(ctx, watchPattern, nil, events, errors)
 		if err != nil {
 			t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
 		}
@@ -107,7 +107,7 @@ func TestWatchDoesNotDebounceSeparateEvents(t *testing.T) {
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
 	}
-	rw, err := Recursive(ctx, watchPattern, events, errors)
+	rw, err := Recursive(ctx, watchPattern, nil, events, errors)
 	if err != nil {
 		t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
 	}
@@ -134,3 +134,74 @@ func TestWatchDoesNotDebounceSeparateEvents(t *testing.T) {
 		}
 	}
 }
+
+func TestWatchIgnoresFilesMatchingIgnorePattern(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	events := make(chan fsnotify.Event, 2)
+	errors := make(chan error)
+	watchPattern, err := regexp.Compile(".*")
+	if err != nil {
+		t.Fatal(fmt.Errorf("failed to compile watch pattern: %w", err))
+	}
+	ignorePattern, err := regexp.Compile(`ignore\.templ$`)
+	if err != nil {
+		t.Fatal(fmt.Errorf("failed to compile ignore pattern: %w", err))
+	}
+
+	rw, err := Recursive(ctx, watchPattern, ignorePattern, events, errors)
+	if err != nil {
+		t.Fatal(fmt.Errorf("failed to create recursive watcher: %w", err))
+	}
+
+	go func() {
+		// This should be ignored
+		rw.w.Events <- fsnotify.Event{Name: "file.ignore.templ"}
+		// This should pass
+		rw.w.Events <- fsnotify.Event{Name: "file.keep.templ"}
+	}()
+
+	count := 0
+	exp := time.After(300 * time.Millisecond)
+	for {
+		select {
+		case <-rw.Events:
+			count++
+		case <-exp:
+			if count != 1 {
+				t.Errorf("expected 1 event, got %d", count)
+			}
+			cancel()
+			if err := rw.Close(); err != nil {
+				t.Errorf("unexpected error closing watcher: %v", err)
+			}
+			return
+		}
+	}
+}
+
+func TestIgnorePatternTakesPrecedenceOverWatchPattern(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	events := make(chan fsnotify.Event, 2)
+	errors := make(chan error)
+	watchPattern := regexp.MustCompile(`.*\.templ$`)
+	ignorePattern := regexp.MustCompile(`.*\.ignore\.templ$`)
+
+	rw, err := Recursive(ctx, watchPattern, ignorePattern, events, errors)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	go func() {
+		rw.w.Events <- fsnotify.Event{Name: "file.ignore.templ"}
+	}()
+
+	exp := time.After(300 * time.Millisecond)
+	select {
+	case <-rw.Events:
+		t.Errorf("expected no events because ignore should win")
+	case <-exp:
+		cancel()
+		_ = rw.Close()
+	}
+}