A file watcher that runs commands. A work in progress.

go get github.com/pranavraja/watchcmd

Assuming $GOPATH is in your $PATH:

watchcmd

...will watch the current directory for changes and run the commands in watchcmd.rules accordingly.

See the output of watchcmd -h:

Usage of ./watchcmd:
  -directory=".": directory to watch (e.g. --directory src). Defaults to
   the current dir
  -rules="watchcmd.rules": file containing rules of the form
   event<TAB>regexp<TAB>command (default filename is watchcmd.rules)
  -batchUpdate=1: to prevent unnecessary runs, if multiple files tend to be
   updated in a batch, the typical duration (in milliseconds) to wait for
   that batch

The rules file contains the patterns to watch (as regular expressions), and the commands to execute. An example rule:

MODIFY	\.js$	grunt browserify

The above rule executes grunt browserify whenever any file (or set of files) with extension .js is modified. Note that if multiple files matching the pattern are updated at the same time (see Batch updates below), the command will only be run once.

Regexp substitution is also supported, for example:

MODIFY	src\/(.+)\.jade$	jade < src/$1.jade > dist/$1.html

This runs the jade executable for each modified .jade file under the path src/, replacing a html file of the same name under the path dist/. Directory structure is preserved. This rule can be useful when developing static sites, for example.

You can also listen for CREATE and DELETE events, for example:

CREATE	src/(.+)	mkdir -p dist/`dirname $1`

This will copy directory structures for files created under src/.

REMOVE	src/(.+)	rm dist/$1

This will remove the corresponding file from dist/ when it is deleted from src/.

One of the annoyances with watchers is that if multiple files have changed within a short timeframe, the tasks can be run multiple times unnecessarily. For example, if you have a single build task for your entire project, you don't want to be triggering it 10 times just because you changed 10 files. If the end result is going to be the same, that's 9 wasted builds.

watchcmd supports passing in a --batchUpdate parameter, which represents the time between the first and last update of a batch. This can be useful in a bunch of scenarios, for example dependent build tasks, or when you use vim and a single :w ends up writing the file like 6 times.