config 3.0.1 → 3.2.2

package/History.md

@@ -1,3 +1,25 @@
+3.2.2 / 2019-07-20
+==================
+
+  * Fixed delimiter bug in configDirs to match O/S delimiter - @iMoses
+
+3.2.1 / 2019-07-18
+==================
+
+  * Fixed TypeError: obj.toString is not a function - @leosuncin
+
+3.2.0 / 2019-07-11
+==================
+
+  * Asynchronous configs - @iMoses
+  * Multiple config directories - @iMoses
+  * Improved parser support - @iMoses
+
+3.1.0 / 2019-04-07
+==================
+
+  * Support of module.exports syntax for TS config files @keenondrums
+
 3.0.1 / 2018-12-16
 ==================
 

package/README.md

@@ -80,13 +80,13 @@ $ vi config/default.json
 **Use configs in your code:**
 
 ```js
-var config = require('config');
+const config = require('config');
 //...
-var dbConfig = config.get('Customer.dbConfig');
+const dbConfig = config.get('Customer.dbConfig');
 db.connect(dbConfig, ...);
 
 if (config.has('optionalFeature.detail')) {
-  var detail = config.get('optionalFeature.detail');
+  const detail = config.get('optionalFeature.detail');
   //...
 }
 ```
@@ -141,13 +141,13 @@ Contributors
 <td><img src=https://avatars0.githubusercontent.com/u/66902?v=4><a href="https://github.com/leachiM2k">leachiM2k</a></td>
 <td><img src=https://avatars1.githubusercontent.com/u/791137?v=4><a href="https://github.com/josx">josx</a></td>
 </tr><tr><td><img src=https://avatars2.githubusercontent.com/u/133277?v=4><a href="https://github.com/enyo">enyo</a></td>
+<td><img src=https://avatars1.githubusercontent.com/u/4307697?v=4><a href="https://github.com/leosuncin">leosuncin</a></td>
 <td><img src=https://avatars3.githubusercontent.com/u/1077378?v=4><a href="https://github.com/arthanzel">arthanzel</a></td>
 <td><img src=https://avatars2.githubusercontent.com/u/1656140?v=4><a href="https://github.com/eheikes">eheikes</a></td>
-<td><img src=https://avatars0.githubusercontent.com/u/355800?v=4><a href="https://github.com/diversario">diversario</a></td>
 <td><img src=https://avatars3.githubusercontent.com/u/138707?v=4><a href="https://github.com/th507">th507</a></td>
 <td><img src=https://avatars2.githubusercontent.com/u/506460?v=4><a href="https://github.com/Osterjour">Osterjour</a></td>
 </tr><tr><td><img src=https://avatars0.githubusercontent.com/u/842998?v=4><a href="https://github.com/nsabovic">nsabovic</a></td>
-<td><img src=https://avatars0.githubusercontent.com/u/5138570?v=4><a href="https://github.com/ScionOfBytes">ScionOfBytes</a></td>
+<td><img src=https://avatars0.githubusercontent.com/u/5138570?v=4><a href="https://github.com/BadgerBadgerBadgerBadger">BadgerBadgerBadgerBadger</a></td>
 <td><img src=https://avatars2.githubusercontent.com/u/2529835?v=4><a href="https://github.com/simon-scherzinger">simon-scherzinger</a></td>
 <td><img src=https://avatars1.githubusercontent.com/u/175627?v=4><a href="https://github.com/axelhzf">axelhzf</a></td>
 <td><img src=https://avatars3.githubusercontent.com/u/7782055?v=4><a href="https://github.com/benkroeger">benkroeger</a></td>

package/async.js

@@ -0,0 +1,70 @@
+var asyncSymbol = Symbol('asyncSymbol');
+var deferConfig = require('./defer').deferConfig;
+
+/**
+ * @param promiseOrFunc   the promise will determine a property's value once resolved
+ *                        can also be a function to defer which resolves to a promise
+ * @returns {Promise}     a marked promise to be resolve later using `resolveAsyncConfigs`
+ */
+function asyncConfig(promiseOrFunc) {
+  if (typeof promiseOrFunc === 'function') {  // also acts as deferConfig
+    return deferConfig(function (config, original) {
+      var release;
+      function registerRelease(resolve) { release = resolve; }
+      function callFunc() { return promiseOrFunc.call(config, config, original); }
+      var promise = asyncConfig(new Promise(registerRelease).then(callFunc));
+      promise.release = release;
+      return promise;
+    });
+  }
+  var promise = promiseOrFunc;
+  promise.async = asyncSymbol;
+  promise.prepare = function(config, prop, property) {
+    if (promise.release) {
+      promise.release();
+    }
+    return function() {
+      return promise.then(function(value) {
+        Object.defineProperty(prop, property, {value: value});
+      });
+    };
+  };
+  return promise;
+}
+
+/**
+ * Do not use `config.get` before executing this method, it will freeze the config object
+ * @param config    the main config object, returned from require('config')
+ * @returns {Promise<config>}   once all promises are resolved, return the original config object
+ */
+function resolveAsyncConfigs(config) {
+  var promises = [];
+  var resolvers = [];
+  (function iterate(prop) {
+    var propsToSort = [];
+    for (var property in prop) {
+      if (prop.hasOwnProperty(property) && prop[property] != null) {
+        propsToSort.push(property);
+      }
+    }
+    propsToSort.sort().forEach(function(property) {
+      if (prop[property].constructor === Object) {
+        iterate(prop[property]);
+      }
+      else if (prop[property].constructor === Array) {
+        prop[property].forEach(iterate);
+      }
+      else if (prop[property] && prop[property].async === asyncSymbol) {
+        resolvers.push(prop[property].prepare(config, prop, property));
+        promises.push(prop[property]);
+      }
+    });
+  })(config);
+  return Promise.all(promises).then(function() {
+    resolvers.forEach(function(resolve) { resolve(); });
+    return config;
+  });
+}
+
+module.exports.asyncConfig = asyncConfig;
+module.exports.resolveAsyncConfigs = resolveAsyncConfigs;

package/defer.js

@@ -1,12 +1,21 @@
 // Create a deferredConfig prototype so that we can check for it when reviewing the configs later.
-function DeferredConfig () {
-}
-DeferredConfig.prototype.resolve = function (config, original) {};
+function DeferredConfig() {}
+DeferredConfig.prototype.prepare = function() {};
+DeferredConfig.prototype.resolve = function() {};
 
 // Accept a function that we'll use to resolve this value later and return a 'deferred' configuration value to resolve it later.
-function deferConfig (func) {
+function deferConfig(func) {
   var obj = Object.create(DeferredConfig.prototype);
-  obj.resolve = func;
+  obj.prepare = function(config, prop, property) {
+    var original = prop[property]._original;
+    obj.resolve = function() {
+      var value = func.call(config, config, original);
+      Object.defineProperty(prop, property, {value: value});
+      return value;
+    };
+    Object.defineProperty(prop, property, {get: function() { return obj.resolve(); }});
+    return obj;
+  };
   return obj;
 }
 

package/lib/config.js

@@ -4,19 +4,10 @@
 // http://lorenwest.github.com/node-config
 
 // Dependencies
-var Yaml = null,    // External libraries are lazy-loaded
-    VisionmediaYaml = null,  // only if these file types exist.
-    Coffee = null,
-    Iced = null,
-    CSON = null,
-    PPARSER = null,
-    JSON5 = null,
-    TOML = null,
-    HJSON = null,
-    XML = null,
-    deferConfig = require('../defer').deferConfig,
+var deferConfig = require('../defer').deferConfig,
     DeferredConfig = require('../defer').DeferredConfig,
     RawConfig = require('../raw').RawConfig,
+    Parser = require('../parser'),
     Utils = require('util'),
     Path = require('path'),
     FileSystem = require('fs');
@@ -25,6 +16,7 @@ var Yaml = null,    // External libraries are lazy-loaded
 var DEFAULT_CLONE_DEPTH = 20,
     NODE_CONFIG, CONFIG_DIR, RUNTIME_JSON_FILENAME, NODE_ENV, APP_INSTANCE,
     HOST, HOSTNAME, ALLOW_CONFIG_MUTATIONS, CONFIG_SKIP_GITCRYPT,
+    NODE_CONFIG_PARSER,
     env = {},
     privateUtil = {},
     deprecationWarnings = {},
@@ -32,20 +24,6 @@ var DEFAULT_CLONE_DEPTH = 20,
     checkMutability = true,      // Check for mutability/immutability on first get
     gitCryptTestRegex = /^.GITCRYPT/; // regular expression to test for gitcrypt files.
 
-// Define soft dependencies so transpilers don't include everything
-var COFFEE_2_DEP = "coffeescript",
-COFFEE_DEP = "coffee-script",
-ICED_DEP = "iced-coffee-script",
-JS_YAML_DEP = "js-yaml",
-YAML_DEP = "yaml",
-JSON5_DEP = "json5",
-HJSON_DEP = "hjson",
-TOML_DEP = "toml",
-CSON_DEP = "cson",
-PPARSER_DEP = "properties",
-XML_DEP = "x2js",
-TS_DEP = "ts-node";
-
 /**
  * <p>Application Configurations</p>
  *
@@ -129,7 +107,9 @@ var Config = function() {
 
   // Bind all utility functions to this
   for (var fnName in util) {
-    util[fnName] = util[fnName].bind(t);
+    if (typeof util[fnName] === 'function') {
+      util[fnName] = util[fnName].bind(t);
+    }
   }
 
   // Merge configurations into this
@@ -151,7 +131,7 @@ var util = Config.prototype.util = {};
  * @private
  * @method getImpl
  * @param object {object} - Object to get the property for
- * @param property {string | array[string]} - The property name to get (as an array or '.' delimited string)
+ * @param property {string|string[]} - The property name to get (as an array or '.' delimited string)
  * @return value {*} - Property value, including undefined if not defined.
  */
 var getImpl= function(object, property) {
@@ -169,7 +149,6 @@ var getImpl= function(object, property) {
   return getImpl(value, elems.slice(1));
 };
 
-
 /**
  * <p>Get a configuration value</p>
  *
@@ -553,6 +532,20 @@ util.loadFileConfigs = function(configDir) {
   // This is for backward compatibility
   RUNTIME_JSON_FILENAME = util.initParam('NODE_CONFIG_RUNTIME_JSON', Path.join(CONFIG_DIR , 'runtime.json') );
 
+  NODE_CONFIG_PARSER = util.initParam('NODE_CONFIG_PARSER');
+  if (NODE_CONFIG_PARSER) {
+    try {
+      var parserModule = Path.isAbsolute(NODE_CONFIG_PARSER)
+        ? NODE_CONFIG_PARSER
+        : Path.join(CONFIG_DIR, NODE_CONFIG_PARSER);
+      Parser = require(parserModule);
+    }
+    catch (e) {
+      console.warn('Failed to load config parser from ' + NODE_CONFIG_PARSER);
+      console.log(e);
+    }
+  }
+
   // Determine the host name from the OS module, $HOST, or $HOSTNAME
   // Remove any . appendages, and default to null if not set
   try {
@@ -573,7 +566,7 @@ util.loadFileConfigs = function(configDir) {
   var baseNames = ['default'].concat(NODE_ENV);
 
   // #236: Also add full hostname when they are different.
-  if ( hostName ) {
+  if (hostName) {
     var firstDomain = hostName.split('.')[0];
 
     NODE_ENV.forEach(function(env) {
@@ -581,7 +574,7 @@ util.loadFileConfigs = function(configDir) {
       baseNames.push(firstDomain, firstDomain + '-' + env);
 
       // Add full hostname when it is not the same
-      if ( hostName != firstDomain ) {
+      if (hostName !== firstDomain) {
         baseNames.push(hostName, hostName + '-' + env);
       }
     });
@@ -591,28 +584,26 @@ util.loadFileConfigs = function(configDir) {
     baseNames.push('local', 'local-' + env);
   });
 
-  var extNames = ['js', 'ts', 'json', 'json5', 'hjson', 'toml', 'coffee', 'iced', 'yaml', 'yml', 'cson', 'properties', 'xml'];
+  var allowedFiles = {};
+  var resolutionIndex = 1;
+  var extNames = Parser.getFilesOrder();
   baseNames.forEach(function(baseName) {
     extNames.forEach(function(extName) {
-
-      // Try merging the config object into this object
-      var fullFilename = Path.join(CONFIG_DIR , baseName + '.' + extName);
-      var configObj = util.parseFile(fullFilename);
-      if (configObj) {
-        util.extendDeep(config, configObj);
-      }
-
-      // See if the application instance file is available
+      allowedFiles[baseName + '.' + extName] = resolutionIndex++;
       if (APP_INSTANCE) {
-        fullFilename = Path.join(CONFIG_DIR, baseName + '-' + APP_INSTANCE + '.' + extName);
-        configObj = util.parseFile(fullFilename);
-        if (configObj) {
-          util.extendDeep(config, configObj);
-        }
+        allowedFiles[baseName + '-' + APP_INSTANCE + '.' + extName] = resolutionIndex++;
       }
     });
   });
 
+  var locatedFiles = util.locateMatchingFiles(CONFIG_DIR, allowedFiles);
+  locatedFiles.forEach(function(fullFilename) {
+    var configObj = util.parseFile(fullFilename);
+    if (configObj) {
+      util.extendDeep(config, configObj);
+    }
+  });
+
   // Override configurations from the $NODE_CONFIG environment variable
   // NODE_CONFIG only applies to the base config
   if (!configDir) {
@@ -663,10 +654,39 @@ util.loadFileConfigs = function(configDir) {
   return config;
 };
 
+/**
+ * Return a list of fullFilenames who exists in allowedFiles
+ * Ordered according to allowedFiles argument specifications
+ *
+ * @protected
+ * @method locateMatchingFiles
+ * @param configDirs {string}   the config dir, or multiple dirs separated by a column (:)
+ * @param allowedFiles {object} an object. keys and supported filenames
+ *                              and values are the position in the resolution order
+ * @returns {string[]}          fullFilenames - path + filename
+ */
+util.locateMatchingFiles = function(configDirs, allowedFiles) {
+  return configDirs.split(Path.delimiter)
+    .reduce(function(files, configDir) {
+      if (configDir) {
+        try {
+          FileSystem.readdirSync(configDir).forEach(function(file) {
+            if (allowedFiles[file]) {
+              files.push([allowedFiles[file], Path.join(configDir, file)]);
+            }
+          });
+        }
+        catch(e) {}
+        return files;
+      }
+    }, [])
+    .sort(function(a, b) { return a[0] - b[0]; })
+    .map(function(file) { return file[1]; });
+};
+
 // Using basic recursion pattern, find all the deferred values and resolve them.
 util.resolveDeferredConfigs = function (config) {
-  var completeConfig = config;
-
+  var deferred = [];
 
   function _iterate (prop) {
 
@@ -682,25 +702,30 @@ util.resolveDeferredConfigs = function (config) {
 
     // Second step is to iterate of the elements in a predictable (sorted) order
     propsToSort.sort().forEach(function (property) {
-      if (prop[property].constructor == Object) {
+      if (prop[property].constructor === Object) {
         _iterate(prop[property]);
-      } else if (prop[property].constructor == Array) {
+      } else if (prop[property].constructor === Array) {
         for (var i = 0; i < prop[property].length; i++) {
-          _iterate(prop[property][i]);
+          if (prop[property][i] instanceof DeferredConfig) {
+            deferred.push(prop[property][i].prepare(config, prop[property], i));
+          }
+          else {
+            _iterate(prop[property][i]);
+          }
         }
       } else {
-        if (prop[property] instanceof DeferredConfig ) {
-          prop[property]= prop[property].resolve.call(completeConfig,completeConfig, prop[property]._original);
-        }
-        else {
-          // Nothing to do. Keep the property how it is.
+        if (prop[property] instanceof DeferredConfig) {
+          deferred.push(prop[property].prepare(config, prop, property));
         }
+        // else: Nothing to do. Keep the property how it is.
       }
     });
   }
 
-    _iterate(config);
-}
+  _iterate(config);
+
+  deferred.forEach(function (defer) { defer.resolve(); });
+};
 
 /**
  * Parse and return the specified configuration file.
@@ -725,36 +750,27 @@ util.resolveDeferredConfigs = function (config) {
  * @protected
  * @method parseFile
  * @param fullFilename {string} The full file path and name
- * @return {configObject} The configuration object parsed from the file
+ * @return configObject {object|null} The configuration object parsed from the file
  */
 util.parseFile = function(fullFilename) {
-
-  // Initialize
-  var t = this,
-      extension = fullFilename.substr(fullFilename.lastIndexOf('.') + 1),
+  var t = this,  // Initialize
       configObject = null,
       fileContent = null,
       stat = null;
 
-  // Return null if the file doesn't exist.
   // Note that all methods here are the Sync versions.  This is appropriate during
   // module loading (which is a synchronous operation), but not thereafter.
-  try {
-    stat = FileSystem.statSync(fullFilename);
-    if (!stat || stat.size < 1) {
-      return null;
-    }
-  } catch (e1) {
-    return null
-  }
 
-  // Try loading the file.
   try {
-    fileContent = FileSystem.readFileSync(fullFilename, 'UTF-8');
+    // Try loading the file.
+    fileContent = FileSystem.readFileSync(fullFilename, 'utf-8');
     fileContent = fileContent.replace(/^\uFEFF/, '');
   }
   catch (e2) {
-    throw new Error('Config file ' + fullFilename + ' cannot be read');
+    if (e2.code !== 'ENOENT') {
+      throw new Error('Config file ' + fullFilename + ' cannot be read');
+    }
+    return null;  // file doesn't exists
   }
 
   // Parse the file based on extension
@@ -768,68 +784,7 @@ util.parseFile = function(fullFilename) {
       }
     }
 
-    if (extension === 'js') {
-      // Use the built-in parser for .js files
-      configObject = require(fullFilename);
-    }
-    else if (extension === 'ts') {
-      if (!require.extensions['.ts']) {
-        require(TS_DEP).register({
-          lazy: true,
-          compilerOptions: {
-            allowJs: true,
-          }
-        });
-      }
-
-      // Because of ES6 modules usage, `default` is treated as named export (like any other)
-      // Therefore config is a value of `default` key.
-      configObject = require(fullFilename).default;
-    }
-    else if (extension === 'coffee') {
-      // .coffee files can be loaded with either coffee-script or iced-coffee-script.
-      // Prefer iced-coffee-script, if it exists.
-      // Lazy load the appropriate extension
-      if (!Coffee) {
-        Coffee = {};
-
-        // The following enables iced-coffee-script on .coffee files, if iced-coffee-script is available.
-        // This is commented as per a decision on a pull request.
-        //try {
-        //  Coffee = require("iced-coffee-script");
-        //}
-        //catch (e) {
-        //  Coffee = require("coffee-script");
-        //}
-
-        try {
-          // Try to load coffeescript
-          Coffee = require(COFFEE_2_DEP);
-        }
-        catch (e) {
-          // If it doesn't exist, try to load it using the deprecated module name
-          Coffee = require(COFFEE_DEP);
-        }
-
-        // coffee-script >= 1.7.0 requires explicit registration for require() to work
-        if (Coffee.register) {
-          Coffee.register();
-        }
-      }
-      // Use the built-in parser for .coffee files with coffee-script
-      configObject = require(fullFilename);
-    }
-    else if (extension === 'iced') {
-      Iced = require(ICED_DEP);
-
-      // coffee-script >= 1.7.0 requires explicit registration for require() to work
-      if (Iced.register) {
-        Iced.register();
-      }
-    }
-    else {
-      configObject = util.parseString(fileContent, extension);
-    }
+    configObject = Parser.parse(fullFilename, fileContent);
   }
   catch (e3) {
     if (gitCryptTestRegex.test(fileContent)) {
@@ -877,112 +832,10 @@ util.parseFile = function(fullFilename) {
  * @return {configObject} The configuration object parsed from the string
  */
 util.parseString = function (content, format) {
-  // Initialize
-  var configObject = null;
-
-  // Parse the file based on extension
-  if (format === 'yaml' || format === 'yml') {
-    if (!Yaml && !VisionmediaYaml) {
-      // Lazy loading
-      try {
-        // Try to load the better js-yaml module
-        Yaml = require(JS_YAML_DEP);
-      }
-      catch (e) {
-        try {
-          // If it doesn't exist, load the fallback visionmedia yaml module.
-          VisionmediaYaml = require(YAML_DEP);
-        }
-        catch (e) { }
-      }
-    }
-
-    if (Yaml) {
-      configObject = Yaml.load(content);
-    }
-    else if (VisionmediaYaml) {
-      // The yaml library doesn't like strings that have newlines but don't
-      // end in a newline: https://github.com/visionmedia/js-yaml/issues/issue/13
-      content += '\n';
-      configObject = VisionmediaYaml.eval(util.stripYamlComments(content));
-    }
-    else {
-      console.error("No YAML parser loaded.  Suggest adding js-yaml dependency to your package.json file.")
-    }
-  }
-  else if (format === 'json') {
-    try {
-      configObject = JSON.parse(content);
-    }
-    catch (e) {
-      // All JS Style comments will begin with /, so all JSON parse errors that
-      // encountered a syntax error will complain about this character.
-      if (e.name !== 'SyntaxError' || e.message.indexOf('Unexpected token /') !== 0) {
-        throw e;
-      }
-
-      if (!JSON5) {
-        JSON5 = require(JSON5_DEP);
-      }
-
-      configObject = JSON5.parse(content);
-    }
-  }
-  else if (format === 'json5') {
-
-    if (!JSON5) {
-      JSON5 = require(JSON5_DEP);
-    }
-
-    configObject = JSON5.parse(content);
-
-  } else if (format === 'hjson') {
-
-    if (!HJSON) {
-      HJSON = require(HJSON_DEP);
-    }
-
-    configObject = HJSON.parse(content);
-
-  } else if (format === 'toml') {
-
-    if(!TOML) {
-      TOML = require(TOML_DEP);
-    }
-
-    configObject = TOML.parse(content);
-  }
-  else if (format === 'cson') {
-    if (!CSON) {
-      CSON = require(CSON_DEP);
-    }
-    // Allow comments in CSON files
-    if (typeof CSON.parseSync === 'function') {
-      configObject = CSON.parseSync(util.stripComments(content));
-    } else {
-      configObject = CSON.parse(util.stripComments(content));
-    }
+  var parser = Parser.getParser(format);
+  if (typeof parser === 'function') {
+    return parser(null, content);
   }
-  else if (format === 'properties') {
-    if (!PPARSER) {
-      PPARSER = require(PPARSER_DEP);
-    }
-    configObject = PPARSER.parse(content, { namespaces: true, variables: true, sections: true });
-  } else if (format === 'xml') {
-
-    if (!XML) {
-      XML = require(XML_DEP);
-    }
-
-    var x2js = new XML();
-    configObject = x2js.xml2js(content);
-    var rootKeys = Object.keys(configObject);
-    if(rootKeys.length == 1) {
-      configObject = configObject[rootKeys[0]];
-    }
-  }
-
-  return configObject;
 };
 
 /**
@@ -1119,6 +972,8 @@ util.cloneDeep = function cloneDeep(parent, depth, circular, prototype) {
 
       if (hasGetter){
         Object.defineProperty(child,i,propDescriptor);
+      } else if (util.isPromise(parent[i])) {
+        child[i] = parent[i];
       } else {
         child[i] = _clone(parent[i], depth - 1);
       }
@@ -1384,7 +1239,9 @@ util.extendDeep = function(mergeInto) {
       } else if (util.isObject(mergeInto[prop]) && util.isObject(mergeFrom[prop]) && !isDeferredFunc) {
         util.extendDeep(mergeInto[prop], mergeFrom[prop], depth - 1);
       }
-
+      else if (util.isPromise(mergeFrom[prop])) {
+        mergeInto[prop] = mergeFrom[prop];
+      }
       // Copy recursively if the mergeFrom element is an object (or array or fn)
       else if (mergeFrom[prop] && typeof mergeFrom[prop] === 'object') {
         mergeInto[prop] = util.cloneDeep(mergeFrom[prop], depth -1);
@@ -1404,88 +1261,6 @@ util.extendDeep = function(mergeInto) {
 
 };
 
-/**
- * Strip YAML comments from the string
- *
- * The 2.0 yaml parser doesn't allow comment-only or blank lines.  Strip them.
- *
- * @protected
- * @method stripYamlComments
- * @param fileString {string} The string to strip comments from
- * @return {string} The string with comments stripped.
- */
-util.stripYamlComments = function(fileStr) {
-  // First replace removes comment-only lines
-  // Second replace removes blank lines
-  return fileStr.replace(/^\s*#.*/mg,'').replace(/^\s*[\n|\r]+/mg,'');
-}
-
-/**
- * Strip all Javascript type comments from the string.
- *
- * The string is usually a file loaded from the O/S, containing
- * newlines and javascript type comments.
- *
- * Thanks to James Padolsey, and all who contributed to this implementation.
- * http://james.padolsey.com/javascript/javascript-comment-removal-revisted/
- *
- * @protected
- * @method stripComments
- * @param fileString {string} The string to strip comments from
- * @param stringRegex {RegExp} Optional regular expression to match strings that
- *   make up the config file
- * @return {string} The string with comments stripped.
- */
-util.stripComments = function(fileStr, stringRegex) {
-  stringRegex = stringRegex || /(['"])(\\\1|.)+?\1/g;
-
-  var uid = '_' + +new Date(),
-      primitives = [],
-      primIndex = 0;
-
-  return (
-    fileStr
-
-    /* Remove strings */
-    .replace(stringRegex, function(match){
-      primitives[primIndex] = match;
-      return (uid + '') + primIndex++;
-    })
-
-    /* Remove Regexes */
-    .replace(/([^\/])(\/(?!\*|\/)(\\\/|.)+?\/[gim]{0,3})/g, function(match, $1, $2){
-      primitives[primIndex] = $2;
-      return $1 + (uid + '') + primIndex++;
-    })
-
-    /*
-    - Remove single-line comments that contain would-be multi-line delimiters
-        E.g. // Comment /* <--
-    - Remove multi-line comments that contain would be single-line delimiters
-        E.g. /* // <--
-   */
-    .replace(/\/\/.*?\/?\*.+?(?=\n|\r|$)|\/\*[\s\S]*?\/\/[\s\S]*?\*\//g, '')
-
-    /*
-    Remove single and multi-line comments,
-    no consideration of inner-contents
-   */
-    .replace(/\/\/.+?(?=\n|\r|$)|\/\*[\s\S]+?\*\//g, '')
-
-    /*
-    Remove multi-line comments that have a replaced ending (string/regex)
-    Greedy, so no inner strings/regexes will stop it.
-   */
-    .replace(RegExp('\\/\\*[\\s\\S]+' + uid + '\\d+', 'g'), '')
-
-    /* Bring back strings & regexes */
-    .replace(RegExp(uid + '(\\d+)', 'g'), function(match, n){
-      return primitives[n];
-    })
-  );
-
-};
-
 /**
  * Is the specified argument a regular javascript object?
  *
@@ -1493,13 +1268,25 @@ util.stripComments = function(fileStr, stringRegex) {
  *
  * @protected
  * @method isObject
- * @param arg {*} An argument of any type.
+ * @param obj {*} An argument of any type.
  * @return {boolean} TRUE if the arg is an object, FALSE if not
  */
 util.isObject = function(obj) {
   return (obj !== null) && (typeof obj === 'object') && !(Array.isArray(obj));
 };
 
+/**
+ * Is the specified argument a javascript promise?
+ *
+ * @protected
+ * @method isPromise
+ * @param obj {*} An argument of any type.
+ * @returns {boolean}
+ */
+util.isPromise = function(obj) {
+  return Object.prototype.toString.call(obj) === '[object Promise]';
+};
+
 /**
  * <p>Initialize a parameter from the command line or process environment</p>
  *
@@ -1637,11 +1424,15 @@ util.runStrictnessChecks = function (config) {
       throw new Error(prefix+msg+' '+seeURL);
     }
   }
-}
+};
 
 // Instantiate and export the configuration
 var config = module.exports = new Config();
 
+// copy methods to util for backwards compatibility
+util.stripComments = Parser.stripComments;
+util.stripYamlComments = Parser.stripYamlComments;
+
 // Produce warnings if the configuration is empty
 var showWarnings = !(util.initParam('SUPPRESS_NO_CONFIG_WARNING'));
 if (showWarnings && Object.keys(config).length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "config",
-  "version": "3.0.1",
+  "version": "3.2.2",
   "main": "./lib/config.js",
   "description": "Configuration control for production node deployments",
   "author": "Loren West <open_source@lorenwest.com>",

package/parser.js

@@ -0,0 +1,331 @@
+// External libraries are lazy-loaded only if these file types exist.
+var Yaml = null,
+    VisionmediaYaml = null,
+    Coffee = null,
+    Iced = null,
+    CSON = null,
+    PPARSER = null,
+    JSON5 = null,
+    TOML = null,
+    HJSON = null,
+    XML = null;
+
+// Define soft dependencies so transpilers don't include everything
+var COFFEE_2_DEP = 'coffeescript',
+    COFFEE_DEP = 'coffee-script',
+    ICED_DEP = 'iced-coffee-script',
+    JS_YAML_DEP = 'js-yaml',
+    YAML_DEP = 'yaml',
+    JSON5_DEP = 'json5',
+    HJSON_DEP = 'hjson',
+    TOML_DEP = 'toml',
+    CSON_DEP = 'cson',
+    PPARSER_DEP = 'properties',
+    XML_DEP = 'x2js',
+    TS_DEP = 'ts-node';
+
+var Parser = module.exports;
+
+Parser.parse = function(filename, content) {
+  var parserName = filename.substr(filename.lastIndexOf('.') +1);  // file extension
+  if (typeof definitions[parserName] === 'function') {
+    return definitions[parserName](filename, content);
+  }
+  // TODO: decide what to do in case of a missing parser
+};
+
+Parser.xmlParser = function(filename, content) {
+  if (!XML) {
+    XML = require(XML_DEP);
+  }
+  var x2js = new XML();
+  var configObject = x2js.xml2js(content);
+  var rootKeys = Object.keys(configObject);
+  if(rootKeys.length === 1) {
+    return configObject[rootKeys[0]];
+  }
+  return configObject;
+};
+
+Parser.jsParser = function(filename, content) {
+  return require(filename);
+};
+
+Parser.tsParser = function(filename, content) {
+  if (!require.extensions['.ts']) {
+    require(TS_DEP).register({
+      lazy: true,
+      compilerOptions: {
+        allowJs: true,
+      }
+    });
+  }
+
+  // Imports config if it is exported via module.exports = ...
+  // See https://github.com/lorenwest/node-config/issues/524
+  var configObject = require(filename);
+
+  // Because of ES6 modules usage, `default` is treated as named export (like any other)
+  // Therefore config is a value of `default` key.
+  if (configObject.default) {
+    return configObject.default
+  }
+  return configObject;
+};
+
+Parser.coffeeParser = function(filename, content) {
+  // .coffee files can be loaded with either coffee-script or iced-coffee-script.
+  // Prefer iced-coffee-script, if it exists.
+  // Lazy load the appropriate extension
+  if (!Coffee) {
+    Coffee = {};
+
+    // The following enables iced-coffee-script on .coffee files, if iced-coffee-script is available.
+    // This is commented as per a decision on a pull request.
+    //try {
+    //  Coffee = require('iced-coffee-script');
+    //}
+    //catch (e) {
+    //  Coffee = require('coffee-script');
+    //}
+    try {
+      // Try to load coffeescript
+      Coffee = require(COFFEE_2_DEP);
+    }
+    catch (e) {
+      // If it doesn't exist, try to load it using the deprecated module name
+      Coffee = require(COFFEE_DEP);
+    }
+    // coffee-script >= 1.7.0 requires explicit registration for require() to work
+    if (Coffee.register) {
+      Coffee.register();
+    }
+  }
+  // Use the built-in parser for .coffee files with coffee-script
+  return require(filename);
+};
+
+Parser.icedParser = function(filename, content) {
+  Iced = require(ICED_DEP);
+
+  // coffee-script >= 1.7.0 requires explicit registration for require() to work
+  if (Iced.register) {
+    Iced.register();
+  }
+};
+
+Parser.yamlParser = function(filename, content) {
+  if (!Yaml && !VisionmediaYaml) {
+    // Lazy loading
+    try {
+      // Try to load the better js-yaml module
+      Yaml = require(JS_YAML_DEP);
+    }
+    catch (e) {
+      try {
+        // If it doesn't exist, load the fallback visionmedia yaml module.
+        VisionmediaYaml = require(YAML_DEP);
+      }
+      catch (e) { }
+    }
+  }
+  if (Yaml) {
+    return Yaml.load(content);
+  }
+  else if (VisionmediaYaml) {
+    // The yaml library doesn't like strings that have newlines but don't
+    // end in a newline: https://github.com/visionmedia/js-yaml/issues/issue/13
+    content += '\n';
+    return VisionmediaYaml.eval(Parser.stripYamlComments(content));
+  }
+  else {
+    console.error('No YAML parser loaded.  Suggest adding js-yaml dependency to your package.json file.')
+  }
+};
+
+Parser.jsonParser = function(filename, content) {
+  try {
+    return JSON.parse(content);
+  }
+  catch (e) {
+    // All JS Style comments will begin with /, so all JSON parse errors that
+    // encountered a syntax error will complain about this character.
+    if (e.name !== 'SyntaxError' || e.message.indexOf('Unexpected token /') !== 0) {
+      throw e;
+    }
+    if (!JSON5) {
+      JSON5 = require(JSON5_DEP);
+    }
+    return JSON5.parse(content);
+  }
+};
+
+Parser.json5Parser = function(filename, content) {
+  if (!JSON5) {
+    JSON5 = require(JSON5_DEP);
+  }
+  return JSON5.parse(content);
+};
+
+Parser.hjsonParser = function(filename, content) {
+  if (!HJSON) {
+    HJSON = require(HJSON_DEP);
+  }
+  return HJSON.parse(content);
+};
+
+Parser.tomlParser = function(filename, content) {
+  if(!TOML) {
+    TOML = require(TOML_DEP);
+  }
+  return TOML.parse(content);
+};
+
+Parser.csonParser = function(filename, content) {
+  if (!CSON) {
+    CSON = require(CSON_DEP);
+  }
+  // Allow comments in CSON files
+  if (typeof CSON.parseSync === 'function') {
+    return CSON.parseSync(Parser.stripComments(content));
+  }
+  return CSON.parse(Parser.stripComments(content));
+};
+
+Parser.propertiesParser = function(filename, content) {
+  if (!PPARSER) {
+    PPARSER = require(PPARSER_DEP);
+  }
+  return PPARSER.parse(content, { namespaces: true, variables: true, sections: true });
+};
+
+/**
+ * Strip all Javascript type comments from the string.
+ *
+ * The string is usually a file loaded from the O/S, containing
+ * newlines and javascript type comments.
+ *
+ * Thanks to James Padolsey, and all who contributed to this implementation.
+ * http://james.padolsey.com/javascript/javascript-comment-removal-revisted/
+ *
+ * @protected
+ * @method stripComments
+ * @param fileStr {string} The string to strip comments from
+ * @param stringRegex {RegExp} Optional regular expression to match strings that
+ *   make up the config file
+ * @return {string} The string with comments stripped.
+ */
+Parser.stripComments = function(fileStr, stringRegex) {
+  stringRegex = stringRegex || /(['"])(\\\1|.)+?\1/g;
+
+  var uid = '_' + +new Date(),
+    primitives = [],
+    primIndex = 0;
+
+  return (
+    fileStr
+
+    /* Remove strings */
+      .replace(stringRegex, function(match){
+        primitives[primIndex] = match;
+        return (uid + '') + primIndex++;
+      })
+
+      /* Remove Regexes */
+      .replace(/([^\/])(\/(?!\*|\/)(\\\/|.)+?\/[gim]{0,3})/g, function(match, $1, $2){
+        primitives[primIndex] = $2;
+        return $1 + (uid + '') + primIndex++;
+      })
+
+      /*
+      - Remove single-line comments that contain would-be multi-line delimiters
+          E.g. // Comment /* <--
+      - Remove multi-line comments that contain would be single-line delimiters
+          E.g. /* // <--
+     */
+      .replace(/\/\/.*?\/?\*.+?(?=\n|\r|$)|\/\*[\s\S]*?\/\/[\s\S]*?\*\//g, '')
+
+      /*
+      Remove single and multi-line comments,
+      no consideration of inner-contents
+     */
+      .replace(/\/\/.+?(?=\n|\r|$)|\/\*[\s\S]+?\*\//g, '')
+
+      /*
+      Remove multi-line comments that have a replaced ending (string/regex)
+      Greedy, so no inner strings/regexes will stop it.
+     */
+      .replace(RegExp('\\/\\*[\\s\\S]+' + uid + '\\d+', 'g'), '')
+
+      /* Bring back strings & regexes */
+      .replace(RegExp(uid + '(\\d+)', 'g'), function(match, n){
+        return primitives[n];
+      })
+  );
+
+};
+
+/**
+ * Strip YAML comments from the string
+ *
+ * The 2.0 yaml parser doesn't allow comment-only or blank lines.  Strip them.
+ *
+ * @protected
+ * @method stripYamlComments
+ * @param fileStr {string} The string to strip comments from
+ * @return {string} The string with comments stripped.
+ */
+Parser.stripYamlComments = function(fileStr) {
+  // First replace removes comment-only lines
+  // Second replace removes blank lines
+  return fileStr.replace(/^\s*#.*/mg,'').replace(/^\s*[\n|\r]+/mg,'');
+};
+
+var order = ['js', 'ts', 'json', 'json5', 'hjson', 'toml', 'coffee', 'iced', 'yaml', 'yml', 'cson', 'properties', 'xml'];
+var definitions = {
+  coffee: Parser.coffeeParser,
+  cson: Parser.csonParser,
+  hjson: Parser.hjsonParser,
+  iced: Parser.icedParser,
+  js: Parser.jsParser,
+  json: Parser.jsonParser,
+  json5: Parser.json5Parser,
+  properties: Parser.propertiesParser,
+  toml: Parser.tomlParser,
+  ts: Parser.tsParser,
+  xml: Parser.xmlParser,
+  yaml: Parser.yamlParser,
+  yml: Parser.yamlParser,
+};
+
+Parser.getParser = function(name) {
+  return definitions[name];
+};
+
+Parser.setParser = function(name, parser) {
+  definitions[name] = parser;
+  if (order.indexOf(name) === -1) {
+    order.push(name);
+  }
+};
+
+Parser.getFilesOrder = function(name) {
+  if (name) {
+    return order.indexOf(name);
+  }
+  return order;
+};
+
+Parser.setFilesOrder = function(name, newIndex) {
+  if (Array.isArray(name)) {
+    return order = name;
+  }
+  if (typeof newIndex === 'number') {
+    var index = order.indexOf(name);
+    order.splice(newIndex, 0, name);
+    if (index > -1) {
+      order.splice(index >= newIndex ? index +1 : index, 1);
+    }
+  }
+  return order;
+};