@zappinginc/zm2 6.0.14

package/lib/tools/open.js

@@ -0,0 +1,63 @@
+var exec = require('child_process').exec
+  , path = require('path')
+  ;
+
+
+/**
+ * open a file or uri using the default application for the file type.
+ *
+ * @return {ChildProcess} - the child process object.
+ * @param {string} target - the file/uri to open.
+ * @param {string} appName - (optional) the application to be used to open the
+ *      file (for example, "chrome", "firefox")
+ * @param {function(Error)} callback - called with null on success, or
+ *      an error object that contains a property 'code' with the exit
+ *      code of the process.
+ */
+
+module.exports = open;
+
+function open(target, appName, callback) {
+  var opener;
+
+  if (typeof(appName) === 'function') {
+    callback = appName;
+    appName = null;
+  }
+
+  switch (process.platform) {
+  case 'darwin':
+    if (appName) {
+      opener = 'open -a "' + escape(appName) + '"';
+    } else {
+      opener = 'open';
+    }
+    break;
+  case 'win32':
+    // if the first parameter to start is quoted, it uses that as the title
+    // so we pass a blank title so we can quote the file we are opening
+    if (appName) {
+      opener = 'start "" "' + escape(appName) + '"';
+    } else {
+      opener = 'start ""';
+    }
+    break;
+  default:
+    if (appName) {
+      opener = escape(appName);
+    } else {
+      // use Portlands xdg-open everywhere else
+      opener = path.join(__dirname, './xdg-open');
+    }
+    break;
+  }
+
+  if (process.env.SUDO_USER) {
+    opener = 'sudo -u ' + process.env.SUDO_USER + ' ' + opener;
+  }
+  return exec(opener + ' "' + escape(target) + '"', callback);
+}
+
+function escape(s) {
+  return s.replace(/"/g, '\\\"');
+}

package/lib/tools/passwd.js

@@ -0,0 +1,58 @@
+
+var fs = require('fs')
+
+var getUsers = function() {
+  return fs.readFileSync('/etc/passwd')
+    .toString()
+    .split('\n')
+    .filter(function (user) {
+      return user.length && user[0] != '#';
+    })
+    .reduce(function(map, user) {
+      var fields = user.split(':');
+
+      map[fields[0]] = map[fields[2]] = {
+        username : fields[0],
+        password : fields[1],
+        userId : fields[2],
+        groupId : fields[3],
+        name : fields[4].split(',')[0],
+        homedir : fields[5],
+        shell : fields[6]
+      };
+
+      return map
+    }, {})
+}
+
+var getGroups = function(cb) {
+  var groups
+
+  try {
+    groups = fs.readFileSync('/etc/group')
+  } catch(e) {
+    return e
+  }
+
+  return groups
+    .toString()
+    .split('\n')
+    .filter(function (group) {
+      return group.length && group[0] != '#';
+    })
+    .reduce(function(map, group) {
+      var fields = group.split(':');
+      map[fields[0]] = map[fields[2]] = {
+        name : fields[0],
+        password : fields[1],
+        id : fields[2],
+        members : fields[3].split(',')
+      };
+      return map;
+    }, {})
+}
+
+module.exports = {
+  getUsers,
+  getGroups
+}

package/lib/tools/promise.min.js

@@ -0,0 +1 @@
+!function(e){function n(){}function t(e,n){return function(){e.apply(n,arguments)}}function o(e){if("object"!=typeof this)throw new TypeError("Promises must be constructed via new");if("function"!=typeof e)throw new TypeError("not a function");this._state=0,this._handled=!1,this._value=void 0,this._deferreds=[],s(e,this)}function i(e,n){for(;3===e._state;)e=e._value;return 0===e._state?void e._deferreds.push(n):(e._handled=!0,void o._immediateFn(function(){var t=1===e._state?n.onFulfilled:n.onRejected;if(null===t)return void(1===e._state?r:u)(n.promise,e._value);var o;try{o=t(e._value)}catch(e){return void u(n.promise,e)}r(n.promise,o)}))}function r(e,n){try{if(n===e)throw new TypeError("A promise cannot be resolved with itself.");if(n&&("object"==typeof n||"function"==typeof n)){var i=n.then;if(n instanceof o)return e._state=3,e._value=n,void f(e);if("function"==typeof i)return void s(t(i,n),e)}e._state=1,e._value=n,f(e)}catch(n){u(e,n)}}function u(e,n){e._state=2,e._value=n,f(e)}function f(e){2===e._state&&0===e._deferreds.length&&o._immediateFn(function(){e._handled||o._unhandledRejectionFn(e._value)});for(var n=0,t=e._deferreds.length;n<t;n++)i(e,e._deferreds[n]);e._deferreds=null}function c(e,n,t){this.onFulfilled="function"==typeof e?e:null,this.onRejected="function"==typeof n?n:null,this.promise=t}function s(e,n){var t=!1;try{e(function(e){t||(t=!0,r(n,e))},function(e){t||(t=!0,u(n,e))})}catch(e){if(t)return;t=!0,u(n,e)}}var a=setTimeout;o.prototype.catch=function(e){return this.then(null,e)},o.prototype.then=function(e,t){var o=new this.constructor(n);return i(this,new c(e,t,o)),o},o.all=function(e){var n=Array.prototype.slice.call(e);return new o(function(e,t){function o(r,u){try{if(u&&("object"==typeof u||"function"==typeof u)){var f=u.then;if("function"==typeof f)return void f.call(u,function(e){o(r,e)},t)}n[r]=u,0===--i&&e(n)}catch(e){t(e)}}if(0===n.length)return e([]);for(var i=n.length,r=0;r<n.length;r++)o(r,n[r])})},o.resolve=function(e){return e&&"object"==typeof e&&e.constructor===o?e:new o(function(n){n(e)})},o.reject=function(e){return new o(function(n,t){t(e)})},o.race=function(e){return new o(function(n,t){for(var o=0,i=e.length;o<i;o++)e[o].then(n,t)})},o._immediateFn="function"==typeof setImmediate&&function(e){setImmediate(e)}||function(e){a(e,0)},o._unhandledRejectionFn=function(e){"undefined"!=typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",e)},o._setImmediateFn=function(e){o._immediateFn=e},o._setUnhandledRejectionFn=function(e){o._unhandledRejectionFn=e},"undefined"!=typeof module&&module.exports?module.exports=o:e.Promise||(e.Promise=o)}(this);

package/lib/tools/sexec.js

@@ -0,0 +1,55 @@
+
+var path = require('path');
+var fs = require('fs');
+var child = require('child_process');
+
+var DEFAULT_MAXBUFFER_SIZE = 20 * 1024 * 1024;
+
+function _exec(command, options, callback) {
+  options = options || {};
+
+  if (typeof options === 'function') {
+    callback = options;
+  }
+
+  if (typeof options === 'object' && typeof callback === 'function') {
+    options.async = true;
+  }
+
+  if (!command) {
+    try {
+      console.error('[sexec] must specify command');
+    } catch (e) {
+      return;
+    }
+  }
+
+  options = Object.assign({
+    silent: false,
+    cwd: path.resolve(process.cwd()).toString(),
+    env: process.env,
+    maxBuffer: DEFAULT_MAXBUFFER_SIZE,
+    encoding: 'utf8',
+  }, options);
+
+  var c = child.exec(command, options, function (err, stdout, stderr) {
+    if (callback) {
+      if (!err) {
+        callback(0, stdout, stderr);
+      } else if (err.code === undefined) {
+        // See issue #536
+        /* istanbul ignore next */
+        callback(1, stdout, stderr);
+      } else {
+        callback(err.code, stdout, stderr);
+      }
+    }
+  });
+
+  if (!options.silent) {
+    c.stdout.pipe(process.stdout);
+    c.stderr.pipe(process.stderr);
+  }
+}
+
+module.exports = _exec;

package/lib/tools/treeify.js

@@ -0,0 +1,113 @@
+//     treeify.js
+//     Luke Plaster <notatestuser@gmail.com>
+//     https://github.com/notatestuser/treeify.js
+
+// do the universal module definition dance
+(function (root, factory) {
+
+  if (typeof exports === 'object') {
+    module.exports = factory();
+  } else if (typeof define === 'function' && define.amd) {
+    define(factory);
+  } else {
+    root.treeify = factory();
+  }
+
+}(this, function() {
+
+  function makePrefix(key, last) {
+    var str = (last ? '└' : '├');
+    if (key) {
+      str += '─ ';
+    } else {
+      str += '──┐';
+    }
+    return str;
+  }
+
+  function filterKeys(obj, hideFunctions) {
+    var keys = [];
+    for (var branch in obj) {
+      // always exclude anything in the object's prototype
+      if (!obj.hasOwnProperty(branch)) {
+       continue;
+      }
+      // ... and hide any keys mapped to functions if we've been told to
+      if (hideFunctions && ((typeof obj[branch])==="function")) {
+        continue;
+      }
+      keys.push(branch);
+    }
+    return keys;
+  }
+
+  function growBranch(key, root, last, lastStates, showValues, hideFunctions, callback) {
+    var line = '', index = 0, lastKey, circular, lastStatesCopy = lastStates.slice(0);
+
+    if (lastStatesCopy.push([ root, last ]) && lastStates.length > 0) {
+      // based on the "was last element" states of whatever we're nested within,
+      // we need to append either blankness or a branch to our line
+      lastStates.forEach(function(lastState, idx) {
+        if (idx > 0) {
+          line += (lastState[1] ? ' ' : '│') + '  ';
+        }
+        if ( ! circular && lastState[0] === root) {
+          circular = true;
+        }
+      });
+
+      // the prefix varies based on whether the key contains something to show and
+      // whether we're dealing with the last element in this collection
+      line += makePrefix(key, last) + key;
+
+      // append values and the circular reference indicator
+      showValues && (typeof root !== 'object' || root instanceof Date) && (line += ': ' + root);
+      circular && (line += ' (circular ref.)');
+
+      callback(line);
+    }
+
+    // can we descend into the next item?
+    if ( ! circular && typeof root === 'object') {
+      var keys = filterKeys(root, hideFunctions);
+      keys.forEach(function(branch){
+        // the last key is always printed with a different prefix, so we'll need to know if we have it
+        lastKey = ++index === keys.length;
+
+        // hold your breath for recursive action
+        growBranch(branch, root[branch], lastKey, lastStatesCopy, showValues, hideFunctions, callback);
+      });
+    }
+  };
+
+  // --------------------
+
+  var Treeify = {};
+
+  // Treeify.asLines
+  // --------------------
+  // Outputs the tree line-by-line, calling the lineCallback when each one is available.
+
+  Treeify.asLines = function(obj, showValues, hideFunctions, lineCallback) {
+    /* hideFunctions and lineCallback are curried, which means we don't break apps using the older form */
+    var hideFunctionsArg = typeof hideFunctions !== 'function' ? hideFunctions : false;
+    growBranch('.', obj, false, [], showValues, hideFunctionsArg, lineCallback || hideFunctions);
+  };
+
+  // Treeify.asTree
+  // --------------------
+  // Outputs the entire tree, returning it as a string with line breaks.
+
+  Treeify.asTree = function(obj, showValues, hideFunctions) {
+    var tree = '';
+    growBranch('.', obj, false, [], showValues, hideFunctions, function(line) {
+      tree += line + '\n';
+    });
+    return tree;
+  };
+
+  // --------------------
+
+  return Treeify;
+
+}));

package/lib/tools/which.js

@@ -0,0 +1,120 @@
+
+var fs = require('fs');
+var path = require('path');
+var cst = require('../../constants.js')
+
+// XP's system default value for `PATHEXT` system variable, just in case it's not
+// set on Windows.
+var XP_DEFAULT_PATHEXT = '.com;.exe;.bat;.cmd;.vbs;.vbe;.js;.jse;.wsf;.wsh';
+
+// For earlier versions of NodeJS that doesn't have a list of constants (< v6)
+var FILE_EXECUTABLE_MODE = 1;
+
+function statFollowLinks() {
+  return fs.statSync.apply(fs, arguments);
+}
+
+function isWindowsPlatform() {
+  return cst.IS_WINDOWS;
+}
+
+// Cross-platform method for splitting environment `PATH` variables
+function splitPath(p) {
+  return p ? p.split(path.delimiter) : [];
+}
+
+// Tests are running all cases for this func but it stays uncovered by codecov due to unknown reason
+/* istanbul ignore next */
+function isExecutable(pathName) {
+  try {
+    // TODO(node-support): replace with fs.constants.X_OK once remove support for node < v6
+    fs.accessSync(pathName, FILE_EXECUTABLE_MODE);
+  } catch (err) {
+    return false;
+  }
+  return true;
+}
+
+function checkPath(pathName) {
+  return fs.existsSync(pathName) && !statFollowLinks(pathName).isDirectory()
+    && (isWindowsPlatform() || isExecutable(pathName));
+}
+
+//@
+//@ ### which(command)
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ var nodeExec = which('node');
+//@ ```
+//@
+//@ Searches for `command` in the system's `PATH`. On Windows, this uses the
+//@ `PATHEXT` variable to append the extension if it's not already executable.
+//@ Returns a [ShellString](#shellstringstr) containing the absolute path to
+//@ `command`.
+function _which(cmd) {
+  if (!cmd) console.error('must specify command');
+
+  var options = {}
+
+  var isWindows = isWindowsPlatform();
+  var pathArray = splitPath(process.env.PATH);
+
+  var queryMatches = [];
+
+  // No relative/absolute paths provided?
+  if (cmd.indexOf('/') === -1) {
+    // Assume that there are no extensions to append to queries (this is the
+    // case for unix)
+    var pathExtArray = [''];
+    if (isWindows) {
+      // In case the PATHEXT variable is somehow not set (e.g.
+      // child_process.spawn with an empty environment), use the XP default.
+      var pathExtEnv = process.env.PATHEXT || XP_DEFAULT_PATHEXT;
+      pathExtArray = splitPath(pathExtEnv.toUpperCase());
+    }
+
+    // Search for command in PATH
+    for (var k = 0; k < pathArray.length; k++) {
+      // already found it
+      if (queryMatches.length > 0 && !options.all) break;
+
+      var attempt = path.resolve(pathArray[k], cmd);
+
+      if (isWindows) {
+        attempt = attempt.toUpperCase();
+      }
+
+      var match = attempt.match(/\.[^<>:"/|?*.]+$/);
+      if (match && pathExtArray.indexOf(match[0]) >= 0) { // this is Windows-only
+        // The user typed a query with the file extension, like
+        // `which('node.exe')`
+        if (checkPath(attempt)) {
+          queryMatches.push(attempt);
+          break;
+        }
+      } else { // All-platforms
+        // Cycle through the PATHEXT array, and check each extension
+        // Note: the array is always [''] on Unix
+        for (var i = 0; i < pathExtArray.length; i++) {
+          var ext = pathExtArray[i];
+          var newAttempt = attempt + ext;
+          if (checkPath(newAttempt)) {
+            queryMatches.push(newAttempt);
+            break;
+          }
+        }
+      }
+    }
+  } else if (checkPath(cmd)) { // a valid absolute or relative path
+    queryMatches.push(path.resolve(cmd));
+  }
+
+  if (queryMatches.length > 0) {
+    return options.all ? queryMatches : queryMatches[0];
+  }
+  return options.all ? [] : null;
+}
+
+module.exports = _which;