diff --git a/config/config.go b/config/config.go index c10df3f..7e5687a 100644 --- a/config/config.go +++ b/config/config.go @@ -29,6 +29,7 @@ type Config struct { Walk string `mapstructure:"walk" toml:"walk,omitempty"` WorkingDirectory string `mapstructure:"working-dir" toml:"-"` Stdin bool `mapstructure:"stdin" toml:"-"` // not allowed in config + Watch bool `mapstructure:"watch" toml:"-"` // not allowed in config FormatterConfigs map[string]*Formatter `mapstructure:"formatter" toml:"formatter,omitempty"` @@ -98,6 +99,10 @@ func SetFlags(fs *pflag.FlagSet) { "stdin", false, "Format the context passed in via stdin.", ) + fs.Bool( + "watch", false, + "Watch the filesystem for changes and apply formatters when changes are detected. (env $TREEFMT_WATCH)", + ) fs.String( "tree-root", "", "The root directory from which treefmt will start walking the filesystem (defaults to the directory "+ @@ -157,6 +162,7 @@ func FromViper(v *viper.Viper) (*Config, error) { "clear-cache": false, "no-cache": false, "stdin": false, + "watch": false, "working-dir": ".", } @@ -185,6 +191,11 @@ func FromViper(v *viper.Viper) (*Config, error) { cfg.Walk = walk.Stdin.String() } + // if the watch flag was passed, we force the watch walk type + if cfg.Watch { + cfg.Walk = walk.Watch.String() + } + // determine the tree root if cfg.TreeRoot == "" { // if none was specified, we first try with tree-root-file diff --git a/walk/type_enum.go b/walk/type_enum.go index 4550804..518ad66 100644 --- a/walk/type_enum.go +++ b/walk/type_enum.go @@ -7,11 +7,11 @@ import ( "strings" ) -const _TypeName = "autostdinfilesystemgit" +const _TypeName = "autostdinfilesystemgitwatch" -var _TypeIndex = [...]uint8{0, 4, 9, 19, 22} +var _TypeIndex = [...]uint8{0, 4, 9, 19, 22, 27} -const _TypeLowerName = "autostdinfilesystemgit" +const _TypeLowerName = "autostdinfilesystemgitwatch" func (i Type) String() string { if i < 0 || i >= Type(len(_TypeIndex)-1) { @@ -28,9 +28,10 @@ func _TypeNoOp() { _ = x[Stdin-(1)] _ = x[Filesystem-(2)] _ = x[Git-(3)] + _ = x[Watch-(4)] } -var _TypeValues = []Type{Auto, Stdin, Filesystem, Git} +var _TypeValues = []Type{Auto, Stdin, Filesystem, Git, Watch} var _TypeNameToValueMap = map[string]Type{ _TypeName[0:4]: Auto, @@ -41,6 +42,8 @@ var _TypeNameToValueMap = map[string]Type{ _TypeLowerName[9:19]: Filesystem, _TypeName[19:22]: Git, _TypeLowerName[19:22]: Git, + _TypeName[22:27]: Watch, + _TypeLowerName[22:27]: Watch, } var _TypeNames = []string{ @@ -48,6 +51,7 @@ var _TypeNames = []string{ _TypeName[4:9], _TypeName[9:19], _TypeName[19:22], + _TypeName[22:27], } // TypeString retrieves an enum value from the enum constants string name. diff --git a/walk/walk.go b/walk/walk.go index 7fc3fa0..17ea346 100644 --- a/walk/walk.go +++ b/walk/walk.go @@ -22,6 +22,7 @@ const ( Stdin Filesystem Git + Watch BatchSize = 1024 ) @@ -215,6 +216,8 @@ func NewReader( reader = NewFilesystemReader(root, path, statz, BatchSize) case Git: reader, err = NewGitReader(root, path, statz) + case Watch: + reader, err = NewWatchReader(root, path, statz) default: return nil, fmt.Errorf("unknown walk type: %v", walkType) diff --git a/walk/watch.go b/walk/watch.go new file mode 100644 index 0000000..fa1be1e --- /dev/null +++ b/walk/watch.go @@ -0,0 +1,149 @@ +package walk + +import ( + "context" + "fmt" + "io" + "log" + "os" + "path/filepath" + "strings" + + "github.com/fsnotify/fsnotify" + "github.com/numtide/treefmt/v2/stats" + "golang.org/x/sync/errgroup" +) + +type WatchReader struct { + root string + path string + + log *log.Logger + stats *stats.Stats + + eg *errgroup.Group + watcher *fsnotify.Watcher +} + +func (f *WatchReader) Read(ctx context.Context, files []*File) (n int, err error) { + // ensure we record how many files we traversed + defer func() { + f.stats.Add(stats.Traversed, n) + }() + +LOOP: + // keep filling files up to it's length + for n < len(files) { + select { + // exit early if the context was cancelled + case <-ctx.Done(): + err = ctx.Err() + if err == nil { + return n, fmt.Errorf("context cancelled: %w", ctx.Err()) + } + + return n, nil + + // read the next event from the channel + case event, ok := <-f.watcher.Events: + if !ok { + // channel was closed, exit the loop + err = io.EOF + + break LOOP + } + + // skip if the event is a chmod or rename event since it doesn't + // change the file contents + if event.Has(fsnotify.Chmod) || event.Has(fsnotify.Rename) { + continue + } + + file, err := os.Open(event.Name) + if err != nil { + return n, fmt.Errorf("failed to stat file %s: %w", event.Name, err) + } + defer file.Close() + info, err := file.Stat() + if err != nil { + return n, fmt.Errorf("failed to stat file %s: %w", event.Name, err) + } + + // determine a path relative to the root + relPath, err := filepath.Rel(f.root, event.Name) + if err != nil { + return n, fmt.Errorf("failed to determine a relative path for %s: %w", event.Name, err) + } + + // add to the file array and increment n + files[n] = &File{ + Path: event.Name, + RelPath: relPath, + Info: info, + } + n++ + + case err, ok := <-f.watcher.Errors: + if !ok { + return n, fmt.Errorf("failed to read from watcher: %w", err) + } + f.log.Printf("error: %s", err) + } + } + + return n, err +} + +// Close waits for all watcher processing to complete. +func (f *WatchReader) Close() error { + err := f.watcher.Close() + if err != nil { + return fmt.Errorf("failed to close watcher: %w", err) + } + + err = f.eg.Wait() + if err != nil { + return fmt.Errorf("failed to wait for processing to complete: %w", err) + } + + return nil +} + +func NewWatchReader( + root string, + path string, + statz *stats.Stats, +) (*WatchReader, error) { + // create an error group for managing the processing loop + eg := errgroup.Group{} + + watcher, err := fsnotify.NewWatcher() + if err != nil { + log.Fatalf("failed to create watcher: %v", err) + } + + r := WatchReader{ + root: root, + path: path, + log: log.Default(), + stats: statz, + eg: &eg, + watcher: watcher, + } + + // path is relative to the root, so we create a fully qualified version + // we also clean the path up in case there are any ../../ components etc. + fqPath := filepath.Clean(filepath.Join(root, path)) + + // ensure the path is within the root + if !strings.HasPrefix(fqPath, root) { + return nil, fmt.Errorf("path '%s' is outside of the root '%s'", fqPath, root) + } + + // start watching the path + if err := watcher.Add(fqPath); err != nil { + return nil, fmt.Errorf("failed to watch path %s: %w", fqPath, err) + } + + return &r, nil +}