# 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);
      });

    }