Merge branch 'watch'

task.go

@@ -36,8 +36,7 @@ type Executor struct {
 	Stdout io.Writer
 	Stderr io.Writer
 
-	taskvars      Vars
-	watchingFiles map[string]struct{}
+	taskvars Vars
 
 	taskCallCount map[string]*int32
 
@@ -114,7 +113,7 @@ func (e *Executor) RunTask(ctx context.Context, call Call) error {
 	if !ok {
 		return &taskNotFoundError{call.Task}
 	}
-	if atomic.AddInt32(e.taskCallCount[call.Task], 1) >= MaximumTaskCall {
+	if !e.Watch && atomic.AddInt32(e.taskCallCount[call.Task], 1) >= MaximumTaskCall {
 		return &MaximumTaskCallExceededError{task: call.Task}
 	}
 

watch.go

@@ -5,107 +5,135 @@ import (
 	"strings"
 	"time"
 
-	"github.com/fsnotify/fsnotify"
 	"github.com/mattn/go-zglob"
+	"github.com/radovskyb/watcher"
 )
 
+var watchIgnoredDirs = []string{
+	".git",
+	"node_modules",
+}
+
 // watchTasks start watching the given tasks
 func (e *Executor) watchTasks(args ...string) error {
 	e.printfln("task: Started watching for tasks: %s", strings.Join(args, ", "))
 
-	var isCtxErr = func(err error) bool {
-		switch err {
-		case context.Canceled, context.DeadlineExceeded:
-			return true
-		}
-		return false
-	}
-
 	ctx, cancel := context.WithCancel(context.Background())
 	for _, a := range args {
 		a := a
 		go func() {
-			if err := e.RunTask(ctx, Call{Task: a}); err != nil && !isCtxErr(err) {
+			if err := e.RunTask(ctx, Call{Task: a}); err != nil && !isContextError(err) {
 				e.println(err)
 			}
 		}()
 	}
 
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
+	w := watcher.New()
+	defer w.Close()
+	w.SetMaxEvents(1)
+	if err := w.Ignore(watchIgnoredDirs...); err != nil {
 		return err
 	}
-	defer watcher.Close()
 
 	go func() {
 		for {
-			if err := e.registerWatchedFiles(watcher, args); err != nil {
-				e.printfln("Error watching files: %v", err)
+			select {
+			case event := <-w.Event:
+				e.verbosePrintfln("task: received watch event: %v", event)
+
+				cancel()
+				ctx, cancel = context.WithCancel(context.Background())
+				for _, a := range args {
+					a := a
+					go func() {
+						if err := e.RunTask(ctx, Call{Task: a}); err != nil && !isContextError(err) {
+							e.println(err)
+						}
+					}()
+				}
+			case err := <-w.Error:
+				switch err {
+				case watcher.ErrWatchedFileDeleted:
+					go func() {
+						w.TriggerEvent(watcher.Remove, nil)
+					}()
+				default:
+					e.println(err)
+				}
+			case <-w.Closed:
+				return
 			}
-			time.Sleep(time.Second * 2)
 		}
 	}()
 
-	for {
-		select {
-		case <-watcher.Events:
-			cancel()
-			ctx, cancel = context.WithCancel(context.Background())
-			for _, a := range args {
-				a := a
-				go func() {
-					if err := e.RunTask(ctx, Call{Task: a}); err != nil && !isCtxErr(err) {
-						e.println(err)
-					}
-				}()
+	go func() {
+		// re-register each second because we can have new files
+		for {
+			if err := e.registerWatchedFiles(w, args); err != nil {
+				e.println(err)
 			}
-		case err := <-watcher.Errors:
-			e.println(err)
+			time.Sleep(time.Second)
 		}
-	}
+	}()
+
+	return w.Start(time.Second)
 }
 
-func (e *Executor) registerWatchedFiles(w *fsnotify.Watcher, args []string) error {
-	oldWatchingFiles := e.watchingFiles
-	e.watchingFiles = make(map[string]struct{}, len(oldWatchingFiles))
+func (e *Executor) registerWatchedFiles(w *watcher.Watcher, args []string) error {
+	oldWatchedFiles := make(map[string]struct{})
+	for f := range w.WatchedFiles() {
+		oldWatchedFiles[f] = struct{}{}
+	}
 
-	for k := range oldWatchingFiles {
-		if err := w.Remove(k); err != nil {
+	for f := range oldWatchedFiles {
+		if err := w.Remove(f); err != nil {
 			return err
 		}
 	}
 
-	for _, a := range args {
-		task, ok := e.Tasks[a]
+	var registerTaskFiles func(string) error
+	registerTaskFiles = func(t string) error {
+		task, ok := e.Tasks[t]
 		if !ok {
-			return &taskNotFoundError{a}
+			return &taskNotFoundError{t}
 		}
-		deps := make([]string, len(task.Deps))
-		for i, d := range task.Deps {
-			deps[i] = d.Task
-		}
-		if err := e.registerWatchedFiles(w, deps); err != nil {
-			return err
+
+		for _, d := range task.Deps {
+			if err := registerTaskFiles(d.Task); err != nil {
+				return err
+			}
 		}
+
 		for _, s := range task.Sources {
 			files, err := zglob.Glob(s)
 			if err != nil {
 				return err
 			}
 			for _, f := range files {
+				if _, ok := oldWatchedFiles[f]; ok {
+					continue
+				}
 				if err := w.Add(f); err != nil {
 					return err
 				}
-				e.watchingFiles[f] = struct{}{}
-
-				// run if is new file
-				if oldWatchingFiles != nil {
-					if _, ok := oldWatchingFiles[f]; !ok {
-						w.Events <- fsnotify.Event{Name: f, Op: fsnotify.Create}
-					}
-				}
 			}
 		}
+		return nil
+	}
+
+	for _, a := range args {
+		if err := registerTaskFiles(a); err != nil {
+			return err
+		}
 	}
 	return nil
 }
+
+func isContextError(err error) bool {
+	switch err {
+	case context.Canceled, context.DeadlineExceeded:
+		return true
+	default:
+		return false
+	}
+}