Code coverage report for lib/config/load.js

Statements: 84.21% (48 / 57)      Branches: 66.67% (12 / 18)      Functions: 78.57% (11 / 14)      Lines: 84.21% (48 / 57)     

All files » lib/config/ » load.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 1641 1                 1                   1 8   8   8       8     8     8                 8   8 6     8 3           8 8         8   2     2             6                           1 2   2 2 2 2 2                       1   8 8     8 8   8                   1 16       16     16     16       16 16 16 6     10   10 10 10             10        
'use strict';
var fs = require('fs'),
    path = require('path'),
    exists = fs.exists || path.exists,
    utils = require('../utils'),
    rules = require('../rules'),
    parse = require('../rules/parse'),
    exec = require('./exec'),
    defaults = require('./defaults');
 
module.exports = load;
 
/**
 * Load the nodemon config, first reading the global root/nodemon.json, then
 * the local nodemon.json to the exec and then overwritting using any user
 * specified settings (i.e. from the cli)
 *
 * @param  {Object} settings user defined settings
 * @param  {Function} ready    callback that recieves complete config
 */
function load(settings, options, config, callback) {
  config.loaded = [];
  // first load the root nodemon.json
  loadFile(options, config, utils.home, function (options) {
    // then load the user's local nodemon.json
    loadFile(options, config, process.cwd(), function (options) {
      // Then merge over with the user settings (parsed from the cli).
      // Note that merge protects and favours existing values over new values,
      // and thus command line arguments get priority
      options = utils.merge(settings, options);
 
      // add in any missing defaults
      options = utils.merge(options, defaults);
 
      // work out the execOptions based on the final config we have
      options.execOptions = exec({
        script: options.script,
        exec: options.exec,
        nodeArgs: options.nodeArgs,
        ext: options.ext,
        env: options.env
      }, options.execMap);
 
      // copy the extension across to a user readable format
      options.ext = options.execOptions.ext.replace(/[\*\.\$]/g, '').split('|').join(' ');
 
      if (options.verbose) {
        utils.debug = true;
      }
 
      if (options.quiet) {
        utils.quiet();
      }
 
      // simplify the ready callback to be called after the rules are normalised
      // from strings to regexp through the rules lib. Note that this gets
      // created *after* options is overwritten twice in the lines above.
      var ready = function (options) {
        normaliseRules(options, callback);
      };
 
      // if we didn't pick up a nodemon.json file & there's no cli ignores
      // then try loading an old style .nodemonignore file
      if (config.loaded.length === 0) {
        // TODO decide whether this is just confusing...
        var legacy = loadLegacyIgnore.bind(null, options, ready);
 
        // first try .nodemonignore, if that doesn't exist, try nodemon-ignore
        return legacy('.nodemonignore', function () {
          legacy('nodemon-ignore', function (options) {
            ready(options);
          });
        });
      }
 
      ready(options);
    });
  });
}
 
/**
 * Loads the old style nodemonignore files which are simply a list of patterns
 * in a file to ignore
 *
 * @param  {Object} options    nodemon user options
 * @param  {Function} success
 * @param  {String} filename   the ignore file (.nodemonignore or nodemon-ignore)
 * @param  {Function} fail     (optional) failure callback
 */
function loadLegacyIgnore(options, success, filename, fail) {
  var ignoreFile = path.join(process.cwd(), filename);
 
  exists(ignoreFile, function (exists) {
    Eif (exists) {
      return parse(ignoreFile, function (error, rules) {
        options.ignore = rules.raw;
        success(options);
      });
    }
 
    if (fail) {
      fail(options);
    } else {
      success(options);
    }
  });
}
 
function normaliseRules(options, ready) {
  // convert ignore and watch options to rules/regexp
  rules.watch.add(options.watch);
  rules.ignore.add(options.ignore);
 
  // normalise the watch and ignore arrays
  options.watch = rules.rules.watch;
  options.ignore = rules.rules.ignore;
 
  ready(options);
}
 
/**
 * Looks for a config in the current working directory, and a config in the
 * user's home directory, merging the two together, giving priority to local
 * config. This can then be overwritten later by command line arguments
 *
 * @param  {Function} ready callback to pass loaded settings to
 */
function loadFile(options, config, dir, ready) {
  Iif (!ready) {
    ready = function () {};
  }
 
  var callback = function (settings) {
    // prefer the local nodemon.json and fill in missing items using
    // the global options
    ready(utils.merge(settings, options));
  };
 
  Iif (!dir) {
    return callback({});
  }
 
  var filename = path.join(dir, 'nodemon.json');
  fs.readFile(filename, 'utf8', function (err, data) {
    if (err) {
      return callback({});
    }
 
    var settings = {};
 
    try {
      settings = JSON.parse(data);
      config.loaded.push(filename);
    } catch (e) {
      console.error(e);
      utils.log.fail('Failed to parse config ' + filename);
    }
 
    // options values will overwrite settings
    callback(settings);
  });
 
 
}