1
0
mirror of https://github.com/jesseduffield/lazygit.git synced 2024-12-12 11:15:00 +02:00
lazygit/pkg/gui/file_watching.go

132 lines
3.2 KiB
Go
Raw Normal View History

package gui
import (
"os"
"path/filepath"
"github.com/fsnotify/fsnotify"
"github.com/jesseduffield/lazygit/pkg/commands/models"
2020-10-07 12:19:38 +02:00
"github.com/jesseduffield/lazygit/pkg/utils"
"github.com/sirupsen/logrus"
)
// macs for some bizarre reason cap the number of watchable files to 256.
// there's no obvious platform agonstic way to check the situation of the user's
// computer so we're just arbitrarily capping at 200. This isn't so bad because
// file watching is only really an added bonus for faster refreshing.
2020-01-08 12:41:39 +02:00
const MAX_WATCHED_FILES = 50
type fileWatcher struct {
Watcher *fsnotify.Watcher
WatchedFilenames []string
Log *logrus.Entry
2020-01-12 05:43:43 +02:00
Disabled bool
}
func NewFileWatcher(log *logrus.Entry) *fileWatcher {
2020-03-09 02:34:10 +02:00
// TODO: get this going again, and ensure we don't see any crashes from it
2020-01-12 05:43:43 +02:00
return &fileWatcher{
Disabled: true,
}
}
func (w *fileWatcher) watchingFilename(filename string) bool {
for _, watchedFilename := range w.WatchedFilenames {
if watchedFilename == filename {
return true
}
}
return false
}
func (w *fileWatcher) popOldestFilename() {
// shift the last off the array to make way for this one
oldestFilename := w.WatchedFilenames[0]
w.WatchedFilenames = w.WatchedFilenames[1:]
if err := w.Watcher.Remove(oldestFilename); err != nil {
// swallowing errors here because it doesn't really matter if we can't unwatch a file
w.Log.Error(err)
}
}
func (w *fileWatcher) watchFilename(filename string) {
if err := w.Watcher.Add(filename); err != nil {
// swallowing errors here because it doesn't really matter if we can't watch a file
w.Log.Error(err)
}
// assume we're watching it now to be safe
w.WatchedFilenames = append(w.WatchedFilenames, filename)
}
2020-09-29 10:45:00 +02:00
func (w *fileWatcher) addFilesToFileWatcher(files []*models.File) error {
2020-01-12 05:43:43 +02:00
if w.Disabled {
return nil
}
2020-01-08 12:48:40 +02:00
if len(files) == 0 {
return nil
}
// watch the files for changes
dirName, err := os.Getwd()
if err != nil {
return err
}
2020-01-08 12:48:40 +02:00
for _, file := range files[0:min(MAX_WATCHED_FILES, len(files))] {
2020-01-08 12:57:39 +02:00
if file.Deleted {
continue
}
filename := filepath.Join(dirName, file.Name)
if w.watchingFilename(filename) {
continue
}
if len(w.WatchedFilenames) > MAX_WATCHED_FILES {
w.popOldestFilename()
}
w.watchFilename(filename)
}
return nil
}
2020-01-08 12:48:40 +02:00
func min(a int, b int) int {
if a < b {
return a
}
return b
}
// NOTE: given that we often edit files ourselves, this may make us end up refreshing files too often
// TODO: consider watching the whole directory recursively (could be more expensive)
func (gui *Gui) watchFilesForChanges() {
gui.fileWatcher = NewFileWatcher(gui.Log)
2020-01-12 05:43:43 +02:00
if gui.fileWatcher.Disabled {
return
}
2020-10-07 12:19:38 +02:00
go utils.Safe(func() {
for {
select {
// watch for events
case event := <-gui.fileWatcher.Watcher.Events:
if event.Op == fsnotify.Chmod {
// for some reason we pick up chmod events when they don't actually happen
continue
}
// only refresh if we're not already
if !gui.State.IsRefreshingFiles {
_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{FILES}})
}
// watch for errors
case err := <-gui.fileWatcher.Watcher.Errors:
if err != nil {
gui.Log.Error(err)
}
}
}
2020-10-07 12:19:38 +02:00
})
}