koa-classic-server 1.0.0 → 1.0.2

package/test/node_modules/nodemon/lib/config/load.js

@@ -1,256 +0,0 @@
-var debug = require('debug')('nodemon');
-var fs = require('fs');
-var path = require('path');
-var exists = fs.exists || path.exists;
-var utils = require('../utils');
-var rules = require('../rules');
-var parse = require('../rules/parse');
-var exec = require('./exec');
-var defaults = require('./defaults');
-
-module.exports = load;
-module.exports.mutateExecOptions = mutateExecOptions;
-
-var existsSync = fs.existsSync || path.existsSync;
-
-function findAppScript() {
-  // nodemon has been run alone, so try to read the package file
-  // or try to read the index.js file
-  if (existsSync('./index.js')) {
-    return 'index.js';
-  }
-}
-
-/**
- * Load the nodemon config, first reading the global root/nodemon.json, then
- * the local nodemon.json to the exec and then overwriting using any user
- * specified settings (i.e. from the cli)
- *
- * @param  {Object} settings user defined settings
- * @param  {Function} ready    callback that receives 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 configuration file
-    if (settings.configFile) {
-      options.configFile = path.resolve(settings.configFile);
-    }
-    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);
-
-      // legacy support
-      if (!Array.isArray(options.ignore)) {
-        options.ignore = [options.ignore];
-      }
-
-      if (!options.ignoreRoot) {
-        options.ignoreRoot = defaults.ignoreRoot;
-      }
-
-      // blend the user ignore and the default ignore together
-      if (options.ignoreRoot && options.ignore) {
-        if (!Array.isArray(options.ignoreRoot)) {
-          options.ignoreRoot = [options.ignoreRoot];
-        }
-        options.ignore = options.ignoreRoot.concat(options.ignore);
-      } else {
-        options.ignore = defaults.ignore.concat(options.ignore);
-      }
-
-
-      // add in any missing defaults
-      options = utils.merge(options, defaults);
-
-      if (!options.script && !options.exec) {
-        var found = findAppScript();
-        if (found) {
-          if (!options.args) {
-            options.args = [];
-          }
-          // if the script is found as a result of not being on the command
-          // line, then we move any of the pre double-dash args in execArgs
-          const n = options.scriptPosition === null ?
-            options.args.length : options.scriptPosition;
-
-          options.execArgs = (options.execArgs || [])
-            .concat(options.args.splice(0, n));
-          options.scriptPosition = null;
-
-          options.script = found;
-        }
-      }
-
-      mutateExecOptions(options);
-
-      if (options.quiet) {
-        utils.quiet();
-      }
-
-      if (options.verbose) {
-        utils.debug = true;
-      }
-
-      // 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) {
-        var legacy = loadLegacyIgnore.bind(null, options, config, 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 is a list of patterns
- * in a file to ignore
- *
- * @param  {Object} options    nodemon user options
- * @param  {Function} success
- * @param  {String} filename   ignore file (.nodemonignore or nodemon-ignore)
- * @param  {Function} fail     (optional) failure callback
- */
-function loadLegacyIgnore(options, config, success, filename, fail) {
-  var ignoreFile = path.join(process.cwd(), filename);
-
-  exists(ignoreFile, function (exists) {
-    if (exists) {
-      config.loaded.push(ignoreFile);
-      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 = options.watch === false ? false : 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) {
-  if (!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));
-  };
-
-  if (!dir) {
-    return callback({});
-  }
-
-  var filename = options.configFile || path.join(dir, 'nodemon.json');
-
-  if (config.loaded.indexOf(filename) !== -1) {
-    // don't bother re-parsing the same config file
-    return callback({});
-  }
-
-  fs.readFile(filename, 'utf8', function (err, data) {
-    if (err) {
-      if (err.code === 'ENOENT') {
-        if (!options.configFile && dir !== utils.home) {
-          // if no specified local config file and local nodemon.json
-          // doesn't exist, try the package.json
-          return loadPackageJSON(config, callback);
-        }
-      }
-      return callback({});
-    }
-
-    var settings = {};
-
-    try {
-      settings = JSON.parse(data.toString('utf8').replace(/^\uFEFF/, ''));
-      if (!filename.endsWith('package.json') || settings.nodemonConfig) {
-        config.loaded.push(filename);
-      }
-    } catch (e) {
-      utils.log.fail('Failed to parse config ' + filename);
-      console.error(e);
-      process.exit(1);
-    }
-
-    // options values will overwrite settings
-    callback(settings);
-  });
-}
-
-function loadPackageJSON(config, ready) {
-  if (!ready) {
-    ready = () => { };
-  }
-
-  const dir = process.cwd();
-  const filename = path.join(dir, 'package.json');
-  const packageLoadOptions = { configFile: filename };
-  return loadFile(packageLoadOptions, config, dir, settings => {
-    ready(settings.nodemonConfig || {});
-  });
-}
-
-function mutateExecOptions(options) {
-  // work out the execOptions based on the final config we have
-  options.execOptions = exec({
-    script: options.script,
-    exec: options.exec,
-    args: options.args,
-    scriptPosition: options.scriptPosition,
-    nodeArgs: options.nodeArgs,
-    execArgs: options.execArgs,
-    ext: options.ext,
-    env: options.env,
-  }, options.execMap);
-
-  // clean up values that we don't need at the top level
-  delete options.scriptPosition;
-  delete options.script;
-  delete options.args;
-  delete options.ext;
-
-  return options;
-}

package/test/node_modules/nodemon/lib/help/index.js

@@ -1,27 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-const supportsColor = require('supports-color');
-
-module.exports = help;
-
-const highlight = supportsColor.stdout ? '\x1B\[$1m' : '';
-
-function help(item) {
-  if (!item) {
-    item = 'help';
-  } else if (item === true) { // if used with -h or --help and no args
-    item = 'help';
-  }
-
-  // cleanse the filename to only contain letters
-  // aka: /\W/g but figured this was eaiser to read
-  item = item.replace(/[^a-z]/gi, '');
-
-  try {
-    var dir = path.join(__dirname, '..', '..', 'doc', 'cli', item + '.txt');
-    var body = fs.readFileSync(dir, 'utf8');
-    return body.replace(/\\x1B\[(.)m/g, highlight);
-  } catch (e) {
-    return '"' + item + '" help can\'t be found';
-  }
-}

package/test/node_modules/nodemon/lib/index.js

@@ -1 +0,0 @@
-module.exports = require('./nodemon');

package/test/node_modules/nodemon/lib/monitor/index.js

@@ -1,4 +0,0 @@
-module.exports = {
-  run: require('./run'),
-  watch: require('./watch').watch,
-};

package/test/node_modules/nodemon/lib/monitor/match.js

@@ -1,276 +0,0 @@
-const minimatch = require('minimatch');
-const path = require('path');
-const fs = require('fs');
-const debug = require('debug')('nodemon:match');
-const utils = require('../utils');
-
-module.exports = match;
-module.exports.rulesToMonitor = rulesToMonitor;
-
-function rulesToMonitor(watch, ignore, config) {
-  var monitor = [];
-
-  if (!Array.isArray(ignore)) {
-    if (ignore) {
-      ignore = [ignore];
-    } else {
-      ignore = [];
-    }
-  }
-
-  if (!Array.isArray(watch)) {
-    if (watch) {
-      watch = [watch];
-    } else {
-      watch = [];
-    }
-  }
-
-  if (watch && watch.length) {
-    monitor = utils.clone(watch);
-  }
-
-  if (ignore) {
-    [].push.apply(monitor, (ignore || []).map(function (rule) {
-      return '!' + rule;
-    }));
-  }
-
-  var cwd = process.cwd();
-
-  // next check if the monitored paths are actual directories
-  // or just patterns - and expand the rule to include *.*
-  monitor = monitor.map(function (rule) {
-    var not = rule.slice(0, 1) === '!';
-
-    if (not) {
-      rule = rule.slice(1);
-    }
-
-    if (rule === '.' || rule === '.*') {
-      rule = '*.*';
-    }
-
-    var dir = path.resolve(cwd, rule);
-
-    try {
-      var stat = fs.statSync(dir);
-      if (stat.isDirectory()) {
-        rule = dir;
-        if (rule.slice(-1) !== '/') {
-          rule += '/';
-        }
-        rule += '**/*';
-
-        // `!not` ... sorry.
-        if (!not) {
-          config.dirs.push(dir);
-        }
-      } else {
-        // ensures we end up in the check that tries to get a base directory
-        // and then adds it to the watch list
-        throw new Error();
-      }
-    } catch (e) {
-      var base = tryBaseDir(dir);
-      if (!not && base) {
-        if (config.dirs.indexOf(base) === -1) {
-          config.dirs.push(base);
-        }
-      }
-    }
-
-    if (rule.slice(-1) === '/') {
-      // just slap on a * anyway
-      rule += '*';
-    }
-
-    // if the url ends with * but not **/* and not *.*
-    // then convert to **/* - somehow it was missed :-\
-    if (rule.slice(-4) !== '**/*' &&
-      rule.slice(-1) === '*' &&
-      rule.indexOf('*.') === -1) {
-
-      if (rule.slice(-2) !== '**') {
-        rule += '*/*';
-      }
-    }
-
-
-    return (not ? '!' : '') + rule;
-  });
-
-  return monitor;
-}
-
-function tryBaseDir(dir) {
-  var stat;
-  if (/[?*\{\[]+/.test(dir)) { // if this is pattern, then try to find the base
-    try {
-      var base = path.dirname(dir.replace(/([?*\{\[]+.*$)/, 'foo'));
-      stat = fs.statSync(base);
-      if (stat.isDirectory()) {
-        return base;
-      }
-    } catch (error) {
-      // console.log(error);
-    }
-  } else {
-    try {
-      stat = fs.statSync(dir);
-      // if this path is actually a single file that exists, then just monitor
-      // that, *specifically*.
-      if (stat.isFile() || stat.isDirectory()) {
-        return dir;
-      }
-    } catch (e) { }
-  }
-
-  return false;
-}
-
-function match(files, monitor, ext) {
-  // sort the rules by highest specificity (based on number of slashes)
-  // ignore rules (!) get sorted highest as they take precedent
-  const cwd = process.cwd();
-  var rules = monitor.sort(function (a, b) {
-    var r = b.split(path.sep).length - a.split(path.sep).length;
-    var aIsIgnore = a.slice(0, 1) === '!';
-    var bIsIgnore = b.slice(0, 1) === '!';
-
-    if (aIsIgnore || bIsIgnore) {
-      if (aIsIgnore) {
-        return -1;
-      }
-
-      return 1;
-    }
-
-    if (r === 0) {
-      return b.length - a.length;
-    }
-    return r;
-  }).map(function (s) {
-    var prefix = s.slice(0, 1);
-
-    if (prefix === '!') {
-      if (s.indexOf('!' + cwd) === 0) {
-        return s;
-      }
-
-      // if it starts with a period, then let's get the relative path
-      if (s.indexOf('!.') === 0) {
-        return '!' + path.resolve(cwd, s.substring(1));
-      }
-
-      return '!**' + (prefix !== path.sep ? path.sep : '') + s.slice(1);
-    }
-
-    // if it starts with a period, then let's get the relative path
-    if (s.indexOf('.') === 0) {
-      return path.resolve(cwd, s);
-    }
-
-    if (s.indexOf(cwd) === 0) {
-      return s;
-    }
-
-    return '**' + (prefix !== path.sep ? path.sep : '') + s;
-  });
-
-  debug('rules', rules);
-
-  var good = [];
-  var whitelist = []; // files that we won't check against the extension
-  var ignored = 0;
-  var watched = 0;
-  var usedRules = [];
-  var minimatchOpts = {
-    dot: true,
-  };
-
-  // enable case-insensitivity on Windows
-  if (utils.isWindows) {
-    minimatchOpts.nocase = true;
-  }
-
-  files.forEach(function (file) {
-    file = path.resolve(cwd, file);
-
-    var matched = false;
-    for (var i = 0; i < rules.length; i++) {
-      if (rules[i].slice(0, 1) === '!') {
-        if (!minimatch(file, rules[i], minimatchOpts)) {
-          debug('ignored', file, 'rule:', rules[i]);
-          ignored++;
-          matched = true;
-          break;
-        }
-      } else {
-        debug('matched', file, 'rule:', rules[i]);
-        if (minimatch(file, rules[i], minimatchOpts)) {
-          watched++;
-
-          // don't repeat the output if a rule is matched
-          if (usedRules.indexOf(rules[i]) === -1) {
-            usedRules.push(rules[i]);
-            utils.log.detail('matched rule: ' + rules[i]);
-          }
-
-          // if the rule doesn't match the WATCH EVERYTHING
-          // but *does* match a rule that ends with *.*, then
-          // white list it - in that we don't run it through
-          // the extension check too.
-          if (rules[i] !== '**' + path.sep + '*.*' &&
-            rules[i].slice(-3) === '*.*') {
-            whitelist.push(file);
-          } else if (path.basename(file) === path.basename(rules[i])) {
-            // if the file matches the actual rule, then it's put on whitelist
-            whitelist.push(file);
-          } else {
-            good.push(file);
-          }
-          matched = true;
-          break;
-        } else {
-          // utils.log.detail('no match: ' + rules[i], file);
-        }
-      }
-    }
-    if (!matched) {
-      ignored++;
-    }
-  });
-
-  debug('good', good)
-
-  // finally check the good files against the extensions that we're monitoring
-  if (ext) {
-    if (ext.indexOf(',') === -1) {
-      ext = '**/*.' + ext;
-    } else {
-      ext = '**/*.{' + ext + '}';
-    }
-
-    good = good.filter(function (file) {
-      // only compare the filename to the extension test
-      return minimatch(path.basename(file), ext, minimatchOpts);
-    });
-  } // else assume *.*
-
-  var result = good.concat(whitelist);
-
-  if (utils.isWindows) {
-    // fix for windows testing - I *think* this is okay to do
-    result = result.map(function (file) {
-      return file.slice(0, 1).toLowerCase() + file.slice(1);
-    });
-  }
-
-  return {
-    result: result,
-    ignored: ignored,
-    watched: watched,
-    total: files.length,
-  };
-}