# grunt-contrib-watch [![Build Status](https://travis-ci.org/gruntjs/grunt-contrib-watch.png?branch=master)](https://travis-ci.org/gruntjs/grunt-contrib-watch) > Run predefined tasks whenever watched file patterns are added, changed or deleted. ## Getting Started This plugin requires Grunt `~0.4.0` If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command: ```shell npm install grunt-contrib-watch --save-dev ``` Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript: ```js grunt.loadNpmTasks('grunt-contrib-watch'); ``` ## Watch task _Run this task with the `grunt watch` command._ ### Settings There are a number of options available. Please review the [minimatch options here](https://github.com/isaacs/minimatch#options). As well as some additional options as follows: #### files Type: `String|Array` This defines what file patterns this task will watch. Can be a string or an array of files and/or minimatch patterns. #### tasks Type: `String|Array` This defines which tasks to run when a watched file event occurs. #### options.nospawn Type: `Boolean` Default: false This instructs the watch task to not spawn task runs in a child process. Setting this option also speeds up the reaction time of the watch (usually 500ms faster for most) and allows subsequent task runs to share the same context (i.e., using a reload task). Not spawning task runs can make the watch more prone to failing so please use as needed. Example: ```js watch: { scripts: { files: ['**/*.js'], tasks: ['livereload'], options: { nospawn: true, }, }, }, ``` #### options.interrupt Type: `Boolean` Default: false As files are modified this watch task will spawn tasks in child processes. The default behavior will only spawn a new child process per target when the previous process has finished. Set the `interrupt` option to true to terminate the previous process and spawn a new one upon later changes. Example: ```js watch: { scripts: { files: '**/*.js', tasks: ['jshint'], options: { interrupt: true, }, }, }, ``` #### options.debounceDelay Type: `Integer` Default: 500 How long to wait before emitting events in succession for the same filepath and status. For example if your `Gruntfile.js` file was `changed`, a `changed` event will only fire again after the given milliseconds. Example: ```js watch: { scripts: { files: '**/*.js', tasks: ['jshint'], options: { debounceDelay: 250, }, }, }, ``` #### options.interval Type: `Integer` Default: 100 The `interval` is passed to `fs.watchFile`. Since `interval` is only used by `fs.watchFile` and this watcher also uses `fs.watch`; it is recommended to ignore this option. *Default is 100ms*. #### options.event Type: `String|Array` Default: `'all'` Specify the type watch event that trigger the specified task. This option can be one or many of: `'all'`, `'changed'`, `'added'` and `'deleted'`. Example: ```js watch: { scripts: { files: '**/*.js', tasks: ['generateFileManifest'], options: { event: ['added', 'deleted'], }, }, }, ``` #### options.forever Type: `Boolean` Default: true This is *only a task level option* and cannot be configured per target. By default the watch task will duck punch `grunt.fatal` and `grunt.warn` to try and prevent them from exiting the watch process. If you don't want `grunt.fatal` and `grunt.warn` to be overridden set the `forever` option to `false`. #### options.livereload Type: `Boolean|Number|Object` Default: false Set to `true` or set `livereload: 1337` to a port number to enable live reloading. Default and recommended port is `35729`. If enabled a live reload server will be started with the watch task per target. Then after the indicated tasks have ran, the live reload server will be triggered with the modified files. Example: ```js watch: { css: { files: '**/*.sass', tasks: ['sass'], options: { livereload: true, }, }, }, ``` ### Examples ```js // Simple config to run jshint any time a file is added, changed or deleted grunt.initConfig({ watch: { files: ['**/*'], tasks: ['jshint'], }, }); ``` ```js // Advanced config. Run specific tasks when specific files are added, changed or deleted. grunt.initConfig({ watch: { gruntfile: { files: 'Gruntfile.js', tasks: ['jshint:gruntfile'], }, src: { files: ['lib/*.js', 'css/**/*.scss', '!lib/dontwatch.js'], tasks: ['default'], }, test: { files: '<%= jshint.test.src %>', tasks: ['jshint:test', 'qunit'], }, }, }); ``` #### Using the `watch` event This task will emit a `watch` event when watched files are modified. This is useful if you would like a simple notification when files are edited or if you're using this task in tandem with another task. Here is a simple example using the `watch` event: ```js grunt.initConfig({ watch: { scripts: { files: ['lib/*.js'], }, }, }); grunt.event.on('watch', function(action, filepath) { grunt.log.writeln(filepath + ' has ' + action); }); ``` **The `watch` event is not intended for replacing the standard Grunt API for configuring and running tasks. If you're trying to run tasks from within the `watch` event you're more than likely doing it wrong. Please read [configuring tasks](http://gruntjs.com/configuring-tasks).** ##### Compiling Files As Needed A very common request is to only compile files as needed. Here is an example that will only lint changed files with the `jshint` task: ```js grunt.initConfig({ watch: { scripts: { files: ['lib/*.js'], tasks: ['jshint'], options: { nospawn: true, }, }, }, jshint: { all: ['lib/*.js'], }, }); // on watch events configure jshint:all to only run on changed file grunt.event.on('watch', function(action, filepath) { grunt.config(['jshint', 'all'], filepath); }); ``` If you need to dynamically modify your config, the `nospawn` option must be enabled to keep the watch running under the same context. If you save multiple files simultaneously you may opt for a more robust method: ```js var changedFiles = Object.create(null); var onChange = grunt.util._.debounce(function() { grunt.config(['jshint', 'all'], Object.keys(changedFiles)); changedFiles = Object.create(null); }, 200); grunt.event.on('watch', function(action, filepath) { changedFiles[filepath] = action; onChange(); }); ``` #### Live Reloading Live reloading is built into the watch task. Set the option `livereload` to `true` to enable on the default port `35729` or set to a custom port: `livereload: 1337`. The simplest way to add live reloading to all your watch targets is by setting `livereload` to `true` at the task level. This will run a single live reload server and trigger the live reload for all your watch targets: ```js grunt.initConfig({ watch: { options: { livereload: true, }, css: { files: ['public/scss/*.scss'], tasks: ['compass'], }, }, }); ``` You can also configure live reload for individual watch targets or run multiple live reload servers. Just be sure if you're starting multiple servers they operate on different ports: ```js grunt.initConfig({ watch: { css: { files: ['public/scss/*.scss'], tasks: ['compass'], options: { // Start a live reload server on the default port 35729 livereload: true, }, }, another: { files: ['lib/*.js'], tasks: ['anothertask'], options: { // Start another live reload server on port 1337 livereload: 1337, }, }, dont: { files: ['other/stuff/*'], tasks: ['dostuff'], }, }, }); ``` ##### Enabling Live Reload in Your HTML Once you've started a live reload server you'll be able to access the live reload script. To enable live reload on your page, add a script tag before your closing `` tag pointing to the `livereload.js` script: ```html ``` Feel free to add this script to your template situation and toggle with some sort of `dev` flag. ##### Using Live Reload with the Browser Extension Instead of adding a script tag to your page, you can live reload your page by installing a browser extension. Please visit [how do I install and use the browser extensions](http://feedback.livereload.com/knowledgebase/articles/86242-how-do-i-install-and-use-the-browser-extensions-) for help installing an extension for your browser. Once installed please use the default live reload port `35729` and the browser extension will automatically reload your page without needing the `