Nodemon refactor & JSON config

.gitignore

@@ -13,3 +13,4 @@ results
 
 npm-debug.log
 node_modules
+coverage

.jshintrc

@@ -0,0 +1,14 @@
+{
+  "browser": true,
+  "camelcase": true,
+  "curly": true,
+  "devel": true,
+  "eqeqeq": true,
+  "forin": true,
+  "indent": 2,
+  "noarg": true,
+  "node": true,
+  "quotmark": "single",
+  "undef": true,
+  "unused": true
+}

.travis.yml

@@ -1,9 +1,9 @@
 language: node_js
 node_js:
+  - "0.11"
   - "0.10"
   - "0.8"
 before_script:
-  - npm install -g coffee-script
   - npm install
 notifications:
   email: false

CONTRIBUTING.md

@@ -0,0 +1,8 @@
+# Contribute
+
+WIP - but here's the TL;DR
+
+- .jshintrc
+- new command line options are generally discouraged
+- ensure style is consistent
+- add tests for newly added code (and try to mirror directory and file structure if possible)

README.md

@@ -1,16 +1,11 @@
 # nodemon
 
-[![Flattr this](http://api.flattr.com/button/flattr-badge-large.png)](http://flattr.com/thing/1211372/remynodemon-on-GitHub)
+For use during development of a node.js based application.
 
-For use during development of a node.js based application. 
-
-nodemon will watch the files in the directory where nodemon was started, and if they change, it will automatically restart your node application.
+nodemon will watch the files in the directory that nodemon was started, and if they change, it will automatically restart your node application.
 
 nodemon does **not** require *any* changes to your code or method of development. nodemon simply wraps your node application and keeps an eye on any files that have changed. Remember that nodemon is a replacement wrapper for `node`, think of it as replacing the word "node" on the command line when you run your script.
 
-[![NPM version](https://badge.fury.io/js/nodemon.png)](http://badge.fury.io/js/nodemon)  
-[![Travis Status](https://travis-ci.org/remy/nodemon.png)](https://travis-ci.org/remy/nodemon)
-
 # Installation
 
 Either through forking or by using [npm](http://npmjs.org) (the recommended way):
@@ -43,102 +38,137 @@ You can also pass the debug flag to node through the command line as you would n
 
 If you have a `package.json` file for your app, you can omit the main script entirely and nodemon will read the `package.json` for the `main` property and use that value as the app.
 
-# Automatic re-running
+Also check out the [FAQ](https://github.com/remy/nodemon/blob/master/faq.md) or [issues](https://github.com/remy/nodemon/issues) for nodemon.
+
+## Automatic re-running
+
+nodemon was original written to restart hanging processes such as web servers, but now supports apps that cleanly exit. If your script exits cleanly, nodemon will continue to monitor the directory (or directories) and restart the script if there are any changes.
+
+## Manual restarting
+
+Whilst nodemon is running, if you need to manually restart your application, instead of stopping and restart nodemon, you can simply type `rs` with a carridge return, and nodemon will restart your process.
+
+## Config files
+
+nodemon supports local and global configuration files. These are named `nodemon.json` and can be located in the current working directory or in your home directory.
 
-nodemon was originally written to restart hanging processes such as web servers, but now supports apps that cleanly exit. If your script exits cleanly, nodemon will continue to monitor the directory (or directories) and restart the script if there are any changes.
+The specificity is as follows, so that a command line argument will always override the config file settings:
 
-# Manual restarting
+- command line arguments
+- local config
+- global config
 
-Whilst nodemon is running, if you need to manually restart your application, instead of stopping and restarting nodemon, you can simply type `rs` with a carriage return, and nodemon will restart your process.
+A config file can take any of the command line arguments as JSON key values, for example:
 
-# Running non-node scripts
+    {
+      "verbose": true,
+      "ignore": ["*.test.js", "fixtures/*"]
+      "execMap": {
+        "rb": "ruby",
+        "pde": "processing --sketch={{pwd}} --run"
+      }
+    }
+
+The above `nodemon.json` file might be my global config so that I have support for ruby files and processing files, and I can simply run `nodemon demo.pde` and nodemon will automatically know how to run the script even though out of the box support for processing scripts.
+
+Note that `ignore` and `watch` values are *merged* with your CLI arguments, rather than overwritten.
+
+A further example of options can be seen in [sample-nodemon.md]()
+
+*This section needs better documentation, but for now you can also see `nodemon --help config` ([also here]())*.
+
+## Running non-node scripts
 
 nodemon can also be used to execute and monitor other programs. nodemon will read the file extension of the script being run and monitor that extension instead of .js if there's no .nodemonignore:
 
     nodemon --exec "python -v" ./app.py
 
 Now nodemon will run `app.py` with python in verbose mode (note that if you're not passing args to the exec program, you don't need the quotes), and look for new or modified files with the `.py` extension.
 
-# Monitoring multiple directories
+### Default executables
+
+Using the `nodemon.json` config file, you can define your own default executables using the `execMap` property. This is particularly useful if you're working with a language that isn't supported by default by nodemon.
+
+To add support for nodemon to know about the .pl extension (for Perl), the nodemon.json file would add:
+
+    {
+      "execMap": {
+         "pl": "perl"
+      }
+    }
+
+Now running the following, nodemon will know to use `perl` as the executable:
+
+    nodemon script.pl
+
+It's generally recommended to use the global `nodemon.json` to add your own `execMap` options. However, if there's a common default that's missing, this can be merged in to the project so that nodemon supports it by default, by changing [default.js]() and sending a pull request.
+
+## Monitoring multiple directories
 
 By default nodemon monitors the current working directory. If you want to take control of that option, use the `--watch` option to add specific paths:
 
     nodemon --watch app --watch libs app/server.js
 
 Now nodemon will only restart if there are changes in the `./app` or `./libs` directory. By default nodemon will traverse sub-directories, so there's no need in explicitly including sub-directories.
 
-# Specifying extension watch list
+## Specifying extension watch list
 
-By default, nodemon looks for files with the `.js`, `.coffee`, and `.litcoffee` extensions. If you use the `--exec` option and monitor `app.py` nodemon will monitor files with the extension of `.py`. However, you can specify your own list with the `-e` switch like so:
+By default, nodemon looks for files with the `.js`, `.coffee`, and `.litcoffee` extensions. If you use the `--exec` option and monitor `app.py` nodemon will monitor files with the extension of `.py`. However, you can specify your own list with the `-e` (or `--ext`) switch like so:
 
-    nodemon -e js,css,html
+    nodemon -e js,jade
 
-Or with alternative syntax:
+Now nodemon will restart on any changes to files in the directory (or subdirectories) with the extensions .js, .jade.
 
-    nodemon --ext '.js|.css|.html'
+## Ignoring files
 
-Now nodemon will restart on any changes to files in the directory (or subdirectories) with the extensions .js, .css or .html.
+By default, if nodemon will only restart when a `.js` JavaScript file changes. In some cases you will want to ignore some specific files, directories or file patterns, to prevent nodemon from prematurely restarting your application.
 
-# Delaying restarting
+This can be done via the command line:
 
-In some situations, you may want to wait until a number of files have changed. The timeout before checking for new file changes is 1 second. If you're uploading a number of files and it's taking some number of seconds, this could cause your app to restart multiple times unnecessarily.
+    nodemon --ignore lib/ --ignore tests/
 
-To add an extra throttle, or delay restarting, use the `--delay` command:
+Or specific files can be ignored:
 
-    nodemon --delay 10 server.js
+    nodemon --ignore lib/app.js
 
-The delay figure is number of seconds to delay before restarting. So nodemon will only restart your app the given number of seconds after the *last* file change.
+Patterns can also be ignored (but be sure to quote the arguments):
+
+    nodemon --ignore 'lib/*.js'
 
-# Ignoring files
+Finally regular expressions can be used, but need to be prefixed with a colon (this will ignore all numbered JS files):
 
-By default, if nodemon will only restart when a `.js` JavaScript file changes.  In some cases you will want to ignore some specific files, directories or file patterns, to prevent nodemon from prematurely restarting your application.
+    nodemon --ignore ':(\d)+\.js$'
 
-You can use the [example ignore file](http://github.com/remy/nodemon/blob/master/nodemonignore.example) (note that this example file is not hidden - you must rename it to `.nodemonignore`) as a basis for your nodemon, but it's very simple to create your own:
+Note that by default, nodemon will ignore the `.git` and `node_modules/**/node_modules` directories.
 
-    # this is my ignore file with a nice comment at the top
-
-    /vendor/*     # ignore all external submodules
-    /public/*     # static files
-    ./README.md   # a specific file
-    *.css         # ignore any CSS files too
-    :(\d)*\.js    # monitor javascript files with only digits in their name
+## Delaying restarting
 
-The ignore file accepts:
+In some situations, you may want to wait until a number of files have changed. The timeout before checking for new file changes is 1 second. If you're uploading a number of files and it's taking some number of seconds, this could cause your app to restart multiple time unnecessarily.
 
-* Comments starting with a `#` symbol
-* Blank lines
-* Specific files
-* File patterns (this is converted to a regex, so you have full control of the pattern)
-* Unescaped regex's begining with `:`.
+To add an extra throttle, or delay restarting, use the `--delay` command:
+
+    nodemon --delay 10 server.js
 
-**Note** the `.nodemonignore` file is read from the directory you run nodemon from, *not* from the location of the node script you're running.
+The delay figure is number of seconds to delay before restarting. So nodemon will only restart your app the given number of seconds after the *last* file change.
 
-# Controlling shutdown of your script
+## Controlling shutdown of your script
 
 nodemon sends a kill signal to your application when it sees a file update. If you need to clean up on shutdown inside your script you can capture the kill signal and handle it yourself.
 
 The following example will listen once for the `SIGUSR2` signal (used by nodemon to restart), run the clean up process and then kill itself for nodemon to continue control:
 
     process.once('SIGUSR2', function () {
       gracefulShutdown(function () {
-        process.kill(process.pid, 'SIGUSR2'); 
+        process.kill(process.pid, 'SIGUSR2');
       })
     });
 
 Note that the `process.kill` is *only* called once your shutdown jobs are complete. Hat tip to [Benjie Gillam](http://www.benjiegillam.com/2011/08/node-js-clean-restart-and-faster-development-with-nodemon/) for writing technique this up.
 
-# Using nodemon in your Grunt workflow
+## Using nodemon in your Grunt workflow
 
 Check out the [grunt-nodemon](https://github.com/ChrisWren/grunt-nodemon) plugin to integrate nodemon with the rest of your project's grunt workflow.
 
-# Help! My changes aren't being detected!
-
-nodemon has three potential methods it uses to look for file changes. First, it polls using the find command to search for files modified within the last second. This method works on systems with a BSD based find (Mac, for example). 
-
-Next it tries using node's `fs.watch`. `fs.watch` will not always work however, and nodemon will try and detect if this is the case by writing a file to the tmp directory and seeing if fs.watch is triggered when it's removed. If nodemon finds that fs.watch was not triggered, it will then fall back to the third method (called legacy watch), which works by statting each file in your working directory looking for changes to the last modified time. This is the most cpu intensive method, but it may be the only option on some systems.
-
-In certain cases, like when where you are working on a different drive than your tmp directory is on, `fs.watch` may give you a false positive. You can force nodemon to start using the most compatible legacy method by passing the -L switch, e.g. `nodemon -L /my/odd/file.js`.
-
 # License
 
 MIT [http://rem.mit-license.org](http://rem.mit-license.org)

bin/nodemon.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+'use strict';
+var cli = require('../lib/cli'),
+    nodemon = require('../lib/'),
+    updateNotifier = require('update-notifier'),
+    // checks for available update and returns an instance
+    notifier = updateNotifier({ packagePath: '../package' });
+
+if (notifier.update) {
+  // notify using the built-in convenience method
+  notifier.notify();
+}
+
+var options = cli.parse(process.argv);
+options.restartable = 'rs';
+
+nodemon(options);

doc/arch.md

@@ -0,0 +1,41 @@
+# nodemon code arch
+
+```
+CLI -> parser -> nodemon options -> rules
+
+rules -> configure -> watch -> start process
+```
+
+## CLI examples
+
+Watch src but only *.js and *.coffee
+
+    nodemon --watch src/ -e js,coffee app.js
+
+Parsed to:
+
+    {
+      watch: ['src/'],
+      ignore: [],
+      script: 'app.js'
+      options: {
+        extensions: ['js', 'coffee'],
+        exec: 'node'
+      }
+    }
+
+Watch with no args:
+
+    nodemon
+
+Parsed to (assuming a package.json or index.js is found):
+
+    {
+      watch: [], // meaning all subdirectories
+      ignore: [],
+      script: 'index.js',
+      options: {
+        extensions: ['js'],
+        exec: 'node'
+      }
+    }

doc/cli/authors.txt

@@ -0,0 +1,44 @@
+
+ Remy Sharp - author and maintainer
+    http://github.com/remy
+    http://twitter.com/rem
+
+ project: nodemon
+ commits: 302
+ active : 107 days
+ files  : 73
+ authors:
+   197  Remy Sharp              65.2%
+    40  remy                    13.2%
+     8  Phred                   2.6%
+     8  dylanmcd                2.6%
+     6  Pasindu De Silva        2.0%
+     4  ChrisWren               1.3%
+     3  Albert Netymk           1.0%
+     3  Shawn Biddle            1.0%
+     3  Coen Hyde               1.0%
+     2  Aivo Paas               0.7%
+     2  Christopher Wren        0.7%
+     2  Dylan McDiarmid         0.7%
+     2  Jason Griffin           0.7%
+     2  Josh Davis              0.7%
+     2  Vadim                   0.7%
+     2  fearphage               0.7%
+     1  Alex Sexton             0.3%
+     1  Matthew Andrews         0.3%
+     1  Morgan "ARR!" Allen     0.3%
+     1  Dennis Kehrig           0.3%
+     1  Paul Armstrong          0.3%
+     1  Peter Lyons             0.3%
+     1  Chris Wren              0.3%
+     1  Chris Klaiber           0.3%
+     1  Bryan Kaplan            0.3%
+     1  Todd Wolfson            0.3%
+     1  frekw                   0.3%
+     1  Wil Asche               0.3%
+     1  Everton Ribeiro         0.3%
+     1  Jared Hanson            0.3%
+     1  Alexey Petushkov        0.3%
+     1  Kaushik Shankar         0.3%
+
+ Please contribute http://github.com/remy/nodemon/

doc/cli/config.txt

@@ -0,0 +1,43 @@
+
+  Typically the options to control nodemon are passed in via the CLI and are
+  listed under the default nodemon --help command.
+
+  nodemon can also be configured via a local and global config file:
+
+  * $HOME/nodemon.json
+  * $PWD/nodemon.json
+
+  All config options in the .json file map 1-to-1 with the CLI options, so a
+  config could read as:
+
+    {
+      "ext": "*.pde",
+      "verbose": true,
+      "exec": "processing --sketch=game --run"
+    }
+
+  There are a limited number of variables available in the config (since you
+  could use backticks on the CLI to use a variable, backticks won't work in
+  the .json config).
+
+  * {{pwd}} - the current directory
+  * {{filename}} - the filename you pass to nodemon
+
+  For example:
+
+    {
+      "ext": "*.pde",
+      "verbose": true,
+      "exec": "processing --sketch={{pwd}} --run"
+    }
+
+  The global config file is useful for setting up default default executables
+  instead of needed them in your local config:
+
+    {
+      "verbose": true,
+      "execMap": {
+        "rb": "ruby",
+        "pde": "processing --sketch={{pwd}} --run"
+      }
+    }