passenger 5.0.21 → 5.0.22

data/src/nodejs_supportlib/vendor-copy/network-byte-order/lib/index.js

@@ -0,0 +1,102 @@
+/* Copyright 2010 Membase, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+/*jshint node:true*/
+
+
+/**
+ * Convert a 16-bit quantity (short integer) from host byte order to network byte order (Little-Endian to Big-Endian).
+ *
+ * @param {Array|Buffer} b Array of octets or a nodejs Buffer
+ * @param {number} i Zero-based index at which to write into b
+ * @param {number} v Value to convert
+ */
+exports.htons = function(b, i, v) {
+	b[i] = (0xff & (v >> 8));
+	b[i + 1] = (0xff & (v));
+};
+
+
+/**
+ * Convert a 16-bit quantity (short integer) from network byte order to host byte order (Big-Endian to Little-Endian).
+ *
+ * @param {Array|Buffer} b Array of octets or a nodejs Buffer to read value from
+ * @param {number} i Zero-based index at which to read from b
+ * @returns {number}
+ */
+exports.ntohs = function(b, i) {
+	return ((0xff & b[i]) << 8) | 
+	       ((0xff & b[i + 1]));
+};
+
+
+/**
+ * Convert a 16-bit quantity (short integer) from network byte order to host byte order (Big-Endian to Little-Endian).
+ *
+ * @param {string} s String to read value from
+ * @param {number} i Zero-based index at which to read from s
+ * @returns {number}
+ */
+exports.ntohsStr = function(s, i) {
+	return ((0xff & s.charCodeAt(i)) << 8) |
+	       ((0xff & s.charCodeAt(i + 1)));
+};
+
+
+/**
+ * Convert a 32-bit quantity (long integer) from host byte order to network byte order (Little-Endian to Big-Endian).
+ *
+ * @param {Array|Buffer} b Array of octets or a nodejs Buffer
+ * @param {number} i Zero-based index at which to write into b
+ * @param {number} v Value to convert
+ */
+exports.htonl = function(b, i, v) {
+	b[i] = (0xff & (v >> 24));
+	b[i + 1] = (0xff & (v >> 16));
+	b[i + 2] = (0xff & (v >> 8));
+	b[i + 3] = (0xff & (v));
+};
+
+
+/**
+ * Convert a 32-bit quantity (long integer) from network byte order to host byte order (Big-Endian to Little-Endian).
+ *
+ * @param {Array|Buffer} b Array of octets or a nodejs Buffer to read value from
+ * @param {number} i Zero-based index at which to read from b
+ * @returns {number}
+ */
+exports.ntohl = function(b, i) {
+	return ((0xff & b[i]) << 24) |
+	       ((0xff & b[i + 1]) << 16) |
+	       ((0xff & b[i + 2]) << 8) |
+	       ((0xff & b[i + 3]));
+};
+
+
+/**
+ * Convert a 32-bit quantity (long integer) from network byte order to host byte order (Big-Endian to Little-Endian).
+ *
+ * @param {string} s String to read value from
+ * @param {number} i Zero-based index at which to read from s
+ * @returns {number}
+ */
+exports.ntohlStr = function(s, i) {
+	return ((0xff & s.charCodeAt(i)) << 24) |
+	       ((0xff & s.charCodeAt(i + 1)) << 16) |
+	       ((0xff & s.charCodeAt(i + 2)) << 8) |
+	       ((0xff & s.charCodeAt(i + 3)));
+};

data/src/nodejs_supportlib/vendor-copy/network-byte-order/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "network-byte-order",
+  "description": "htonl, htons, ntohl, ntohs - convert values between host and network byte order.",
+  "version": "0.2.0",
+  "main": "lib/index.js",
+  "homepage": "https://github.com/mattcg/network-byte-order",
+  "implements": [
+    "CommonJS/Modules/1.0"
+  ],
+  "contributors": [
+    {
+      "name": "Matthew Caruana Galizia",
+      "email": "m@m.cg"
+    }
+  ],
+  "keywords": [
+    "htonl",
+    "htons",
+    "ntohl",
+    "ntohs",
+    "byte order",
+    "endian",
+    "endianness",
+    "convert"
+  ],
+  "bugs": {
+    "url": "https://github.com/mattcg/network-byte-order/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mattcg/network-byte-order.git"
+  },
+  "licenses": [
+    {
+      "type": "Apache License, Version 2.0",
+      "url": "http://www.apache.org/licenses/LICENSE-2.0"
+    }
+  ],
+  "devDependencies": {
+    "jscoverage": "0.x",
+    "mocha": "1.x",
+    "mocha-lcov-reporter": "0.x",
+    "coveralls": "2.x"
+  },
+  "readme": "# JavaScript implementation of htonl, htons, ntohl, ntohs #\n\n[![Build Status](https://travis-ci.org/mattcg/network-byte-order.png?branch=master)](https://travis-ci.org/mattcg/network-byte-order)\n[![Coverage Status](https://coveralls.io/repos/mattcg/network-byte-order/badge.png)](https://coveralls.io/r/mattcg/network-byte-order)\n\nThese routines are used for converting values between host and [network byte order](http://en.wikipedia.org/wiki/Endianness#Endianness_in_networking).\n\nDerived from [an implementation](http://blog.couchbase.com/starting-membase-nodejs) by Membase, Inc.\n\n## Usage ##\n\n### htonl(b, i, v) ###\n\nThe `htonl()` function converts the given unsigned 32-bit (long) integer from host byte order to network byte order (Little-Endian to Big-Endian).\n\n`b` is an [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) of octets or a Node.JS [`Buffer`](http://nodejs.org/api/buffer.html).\n`i` is the zero-based index at which to write into `b`.\n`v` is the value to convert.\n\n### htons(b, i, v) ###\n\nThe `htons()` function converts the given unsigned 16-bit (short) integer from host byte order to network byte order (Little-Endian to Big-Endian).\n\n`b` is an [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) of octets or a Node.JS [`Buffer`](http://nodejs.org/api/buffer.html).\n`i` is the zero-based index at which to write into `b`.\n`v` is the value to convert.\n\n### ntohl(b, i) ###\n\nThe `ntohl()` function converts the unsigned 32-bit (long) integer from network byte order to host byte order (Big-Endian to Little-Endian).\n\n`b` is an [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) of octets or a Node.JS [`Buffer`](http://nodejs.org/api/buffer.html) to read the value from.\n`i` is the zero-based index at which to read from `b`.\n\n### ntohlStr(s, i) ###\n\n`s` is a `string` to the read value from.\n`i` is the zero-based index at which to read from `s`.\n\n### ntohs(b, i) ###\n\nThe `ntohs()` function converts the unsigned 16-bit (short) integer from network byte order to host byte order (Big-Endian to Little-Endian).\n\n`b` is an [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) of octets or a Node.JS [`Buffer`](http://nodejs.org/api/buffer.html) to read the value from.\n`i` is the zero-based index at which to read from `b`.\n\n### ntohsStr(s, i) ###\n\n`s` is a `string` to the read value from.\n`i` is the zero-based index at which to read from `s`.\n\n## License ##\n\nLicensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).\n",
+  "readmeFilename": "README.md",
+  "_id": "network-byte-order@0.2.0",
+  "_shasum": "6ac11bf44bf610daeddbe90a09a5c817c6e0d2b3",
+  "_from": "network-byte-order@^0.2.0",
+  "_resolved": "https://registry.npmjs.org/network-byte-order/-/network-byte-order-0.2.0.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/winston/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Charlie Robbins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston.js

@@ -0,0 +1,165 @@
+/*
+ * winston.js: Top-level include defining Winston.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ *
+ */
+
+var winston = exports;
+
+//
+// Expose version using `pkginfo`
+//
+require('pkginfo')(module, 'version');
+
+//
+// Include transports defined by default by winston
+//
+winston.transports = require('./winston/transports');
+
+//
+// Expose utility methods
+//
+var common             = require('./winston/common');
+winston.hash           = common.hash;
+winston.clone          = common.clone;
+winston.longestElement = common.longestElement;
+winston.exception      = require('./winston/exception');
+winston.config         = require('./winston/config');
+winston.addColors      = winston.config.addColors;
+
+//
+// Expose core Logging-related prototypes.
+//
+winston.Container      = require('./winston/container').Container;
+winston.Logger         = require('./winston/logger').Logger;
+winston.Transport      = require('./winston/transports/transport').Transport;
+
+//
+// We create and expose a default `Container` to `winston.loggers` so that the
+// programmer may manage multiple `winston.Logger` instances without any additional overhead.
+//
+// ### some-file1.js
+//
+//     var logger = require('winston').loggers.get('something');
+//
+// ### some-file2.js
+//
+//     var logger = require('winston').loggers.get('something');
+//
+winston.loggers = new winston.Container();
+
+//
+// We create and expose a 'defaultLogger' so that the programmer may do the
+// following without the need to create an instance of winston.Logger directly:
+//
+//     var winston = require('winston');
+//     winston.log('info', 'some message');
+//     winston.error('some error');
+//
+var defaultLogger = new winston.Logger({
+  transports: [new winston.transports.Console()]
+});
+
+//
+// Pass through the target methods onto `winston.
+//
+var methods = [
+  'log',
+  'query',
+  'stream',
+  'add',
+  'remove',
+  'clear',
+  'profile',
+  'startTimer',
+  'extend',
+  'cli',
+  'handleExceptions',
+  'unhandleExceptions',
+  'addRewriter',
+  'addFilter'
+];
+common.setLevels(winston, null, defaultLogger.levels);
+methods.forEach(function (method) {
+  winston[method] = function () {
+    return defaultLogger[method].apply(defaultLogger, arguments);
+  };
+});
+
+//
+// ### function cli ()
+// Configures the default winston logger to have the
+// settings for command-line interfaces: no timestamp,
+// colors enabled, padded output, and additional levels.
+//
+winston.cli = function () {
+  winston.padLevels = true;
+  common.setLevels(winston, defaultLogger.levels, winston.config.cli.levels);
+  defaultLogger.setLevels(winston.config.cli.levels);
+  winston.config.addColors(winston.config.cli.colors);
+
+  if (defaultLogger.transports.console) {
+    defaultLogger.transports.console.colorize = true;
+    defaultLogger.transports.console.timestamp = false;
+  }
+
+  return winston;
+};
+
+//
+// ### function setLevels (target)
+// #### @target {Object} Target levels to use
+// Sets the `target` levels specified on the default winston logger.
+//
+winston.setLevels = function (target) {
+  common.setLevels(winston, defaultLogger.levels, target);
+  defaultLogger.setLevels(target);
+};
+
+//
+// Define getter / setter for the default logger level
+// which need to be exposed by winston.
+//
+Object.defineProperty(winston, 'level', {
+  get: function () {
+    return defaultLogger.level;
+  },
+  set: function (val) {
+    defaultLogger.level = val;
+
+    Object.keys(defaultLogger.transports).forEach(function(key) {
+      defaultLogger.transports[key].level = val;
+    });
+  }
+});
+
+//
+// Define getters / setters for appropriate properties of the
+// default logger which need to be exposed by winston.
+//
+['emitErrs', 'exitOnError', 'padLevels', 'levelLength', 'stripColors'].forEach(function (prop) {
+  Object.defineProperty(winston, prop, {
+    get: function () {
+      return defaultLogger[prop];
+    },
+    set: function (val) {
+      defaultLogger[prop] = val;
+    }
+  });
+});
+
+//
+// @default {Object}
+// The default transports and exceptionHandlers for
+// the default winston logger.
+//
+Object.defineProperty(winston, 'default', {
+  get: function () {
+    return {
+      transports: defaultLogger.transports,
+      exceptionHandlers: defaultLogger.exceptionHandlers
+    };
+  }
+});

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/common.js

@@ -0,0 +1,483 @@
+/*
+ * common.js: Internal helper and utility functions for winston
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ *
+ */
+
+var util = require('util'),
+    crypto = require('crypto'),
+    cycle = require('cycle'),
+    fs = require('fs'),
+    StringDecoder = require('string_decoder').StringDecoder,
+    Stream = require('stream').Stream,
+    config = require('./config');
+
+//
+// ### function setLevels (target, past, current)
+// #### @target {Object} Object on which to set levels.
+// #### @past {Object} Previous levels set on target.
+// #### @current {Object} Current levels to set on target.
+// Create functions on the target objects for each level
+// in current.levels. If past is defined, remove functions
+// for each of those levels.
+//
+exports.setLevels = function (target, past, current, isDefault) {
+  var self = this;
+  if (past) {
+    Object.keys(past).forEach(function (level) {
+      delete target[level];
+    });
+  }
+
+  target.levels = current || config.npm.levels;
+  if (target.padLevels) {
+    target.levelLength = exports.longestElement(Object.keys(target.levels));
+  }
+
+  //
+  //  Define prototype methods for each log level
+  //  e.g. target.log('info', msg) <=> target.info(msg)
+  //
+  Object.keys(target.levels).forEach(function (level) {
+
+    // TODO Refactor logging methods into a different object to avoid name clashes
+    if (level === 'log') {
+      console.warn('Log level named "log" will clash with the method "log". Consider using a different name.');
+      return;
+    }
+
+    target[level] = function (msg) {
+      // build argument list (level, msg, ... [string interpolate], [{metadata}], [callback])
+      var args = [level].concat(Array.prototype.slice.call(arguments));
+      target.log.apply(target, args);
+    };
+  });
+
+  return target;
+};
+
+//
+// ### function longestElement
+// #### @xs {Array} Array to calculate against
+// Returns the longest element in the `xs` array.
+//
+exports.longestElement = function (xs) {
+  return Math.max.apply(
+    null,
+    xs.map(function (x) { return x.length; })
+  );
+};
+
+//
+// ### function clone (obj)
+// #### @obj {Object} Object to clone.
+// Helper method for deep cloning pure JSON objects
+// i.e. JSON objects that are either literals or objects (no Arrays, etc)
+//
+exports.clone = function (obj) {
+  //
+  // We only need to clone reference types (Object)
+  //
+  var copy = {};
+
+  if (obj instanceof Error) {
+    // With potential custom Error objects, this might not be exactly correct,
+    // but probably close-enough for purposes of this lib.
+    copy = new Error(obj.message);
+    Object.getOwnPropertyNames(obj).forEach(function (key) {
+      copy[key] = obj[key];
+    });
+
+    return copy;
+  }
+  else if (!(obj instanceof Object)) {
+    return obj;
+  }
+  else if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+
+  for (var i in obj) {
+    if (Array.isArray(obj[i])) {
+      copy[i] = obj[i].slice(0);
+    }
+    else if (obj[i] instanceof Buffer) {
+        copy[i] = obj[i].slice(0);
+    }
+    else if (typeof obj[i] != 'function') {
+      copy[i] = obj[i] instanceof Object ? exports.clone(obj[i]) : obj[i];
+    }
+    else if (typeof obj[i] === 'function') {
+      copy[i] = obj[i];
+    }
+  }
+
+  return copy;
+};
+
+//
+// ### function log (options)
+// #### @options {Object} All information about the log serialization.
+// Generic logging function for returning timestamped strings
+// with the following options:
+//
+//    {
+//      level:     'level to add to serialized message',
+//      message:   'message to serialize',
+//      meta:      'additional logging metadata to serialize',
+//      colorize:  false, // Colorizes output (only if `.json` is false)
+//      align:     false  // Align message level.
+//      timestamp: true   // Adds a timestamp to the serialized message
+//      label:     'label to prepend the message'
+//    }
+//
+exports.log = function (options) {
+  var timestampFn = typeof options.timestamp === 'function'
+        ? options.timestamp
+        : exports.timestamp,
+      timestamp   = options.timestamp ? timestampFn() : null,
+      showLevel   = options.showLevel === undefined ? true : options.showLevel,
+      meta        = options.meta !== null && options.meta !== undefined && !(options.meta instanceof Error)
+        ? exports.clone(cycle.decycle(options.meta))
+        : options.meta || null,
+      output;
+
+  //
+  // raw mode is intended for outputing winston as streaming JSON to STDOUT
+  //
+  if (options.raw) {
+    if (typeof meta !== 'object' && meta != null) {
+      meta = { meta: meta };
+    }
+    output         = exports.clone(meta) || {};
+    output.level   = options.level;
+    //
+    // Remark (jcrugzz): This used to be output.message = options.message.stripColors.
+    // I do not know why this is, it does not make sense but im handling that
+    // case here as well as handling the case that does make sense which is to
+    // make the `output.message = options.message`
+    //
+    output.message = options.message.stripColors
+      ? options.message.stripColors
+      : options.message;
+
+    return JSON.stringify(output);
+  }
+
+  //
+  // json mode is intended for pretty printing multi-line json to the terminal
+  //
+  if (options.json || true === options.logstash) {
+    if (typeof meta !== 'object' && meta != null) {
+      meta = { meta: meta };
+    }
+
+    output         = exports.clone(meta) || {};
+    output.level   = options.level;
+    output.message = output.message || '';
+
+    if (options.label) { output.label = options.label; }
+    if (options.message) { output.message = options.message; }
+    if (timestamp) { output.timestamp = timestamp; }
+
+    if (options.logstash === true) {
+      // use logstash format
+      var logstashOutput = {};
+      if (output.message !== undefined) {
+        logstashOutput['@message'] = output.message;
+        delete output.message;
+      }
+
+      if (output.timestamp !== undefined) {
+        logstashOutput['@timestamp'] = output.timestamp;
+        delete output.timestamp;
+      }
+
+      logstashOutput['@fields'] = exports.clone(output);
+      output = logstashOutput;
+    }
+
+    if (typeof options.stringify === 'function') {
+      return options.stringify(output);
+    }
+
+    return JSON.stringify(output, function (key, value) {
+      return value instanceof Buffer
+        ? value.toString('base64')
+        : value;
+    });
+  }
+
+  //
+  // Remark: this should really be a call to `util.format`.
+  //
+  if (typeof options.formatter == 'function') {
+    return String(options.formatter(exports.clone(options)));
+  }
+
+  output = timestamp ? timestamp + ' - ' : '';
+  if (showLevel) {
+    output += options.colorize === 'all' || options.colorize === 'level' || options.colorize === true
+      ? config.colorize(options.level)
+      : options.level;
+  }
+
+  output += (options.align) ? '\t' : '';
+  output += (timestamp || showLevel) ? ': ' : '';
+  output += options.label ? ('[' + options.label + '] ') : '';
+  output += options.colorize === 'all' || options.colorize === 'message'
+    ? config.colorize(options.level, options.message)
+    : options.message;
+
+  if (meta !== null && meta !== undefined) {
+    if (meta && meta instanceof Error && meta.stack) {
+      meta = meta.stack;
+    }
+
+    if (typeof meta !== 'object') {
+      output += ' ' + meta;
+    }
+    else if (Object.keys(meta).length > 0) {
+      if (typeof options.prettyPrint === 'function') {
+        output += ' ' + options.prettyPrint(meta);
+      } else if (options.prettyPrint) {
+        output += ' ' + '\n' + util.inspect(meta, false, options.depth || null, options.colorize);
+      } else if (
+        options.humanReadableUnhandledException
+          && Object.keys(meta).length === 5
+          && meta.hasOwnProperty('date')
+          && meta.hasOwnProperty('process')
+          && meta.hasOwnProperty('os')
+          && meta.hasOwnProperty('trace')
+          && meta.hasOwnProperty('stack')) {
+
+        //
+        // If meta carries unhandled exception data serialize the stack nicely
+        //
+        var stack = meta.stack;
+        delete meta.stack;
+        delete meta.trace;
+        output += ' ' + exports.serialize(meta);
+        output += '\n' + stack.join('\n');
+      } else {
+        output += ' ' + exports.serialize(meta);
+      }
+    }
+  }
+
+  return output;
+};
+
+exports.capitalize = function (str) {
+  return str && str[0].toUpperCase() + str.slice(1);
+};
+
+//
+// ### function hash (str)
+// #### @str {string} String to hash.
+// Utility function for creating unique ids
+// e.g. Profiling incoming HTTP requests on the same tick
+//
+exports.hash = function (str) {
+  return crypto.createHash('sha1').update(str).digest('hex');
+};
+
+//
+// ### function pad (n)
+// Returns a padded string if `n < 10`.
+//
+exports.pad = function (n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+};
+
+//
+// ### function timestamp ()
+// Returns a timestamp string for the current time.
+//
+exports.timestamp = function () {
+  return new Date().toISOString();
+};
+
+//
+// ### function serialize (obj, key)
+// #### @obj {Object|literal} Object to serialize
+// #### @key {string} **Optional** Optional key represented by obj in a larger object
+// Performs simple comma-separated, `key=value` serialization for Loggly when
+// logging to non-JSON inputs.
+//
+exports.serialize = function (obj, key) {
+  if (obj === null) {
+    obj = 'null';
+  }
+  else if (obj === undefined) {
+    obj = 'undefined';
+  }
+  else if (obj === false) {
+    obj = 'false';
+  }
+
+  if (typeof obj !== 'object') {
+    return key ? key + '=' + obj : obj;
+  }
+
+  if (obj instanceof Buffer) {
+    return key ? key + '=' + obj.toString('base64') : obj.toString('base64');
+  }
+
+  var msg = '',
+      keys = Object.keys(obj),
+      length = keys.length;
+
+  for (var i = 0; i < length; i++) {
+    if (Array.isArray(obj[keys[i]])) {
+      msg += keys[i] + '=[';
+
+      for (var j = 0, l = obj[keys[i]].length; j < l; j++) {
+        msg += exports.serialize(obj[keys[i]][j]);
+        if (j < l - 1) {
+          msg += ', ';
+        }
+      }
+
+      msg += ']';
+    }
+    else if (obj[keys[i]] instanceof Date) {
+      msg += keys[i] + '=' + obj[keys[i]];
+    }
+    else {
+      msg += exports.serialize(obj[keys[i]], keys[i]);
+    }
+
+    if (i < length - 1) {
+      msg += ', ';
+    }
+  }
+
+  return msg;
+};
+
+//
+// ### function tailFile (options, callback)
+// #### @options {Object} Options for tail.
+// #### @callback {function} Callback to execute on every line.
+// `tail -f` a file. Options must include file.
+//
+exports.tailFile = function(options, callback) {
+  var buffer = new Buffer(64 * 1024)
+    , decode = new StringDecoder('utf8')
+    , stream = new Stream
+    , buff = ''
+    , pos = 0
+    , row = 0;
+
+  if (options.start === -1) {
+    delete options.start;
+  }
+
+  stream.readable = true;
+  stream.destroy = function() {
+    stream.destroyed = true;
+    stream.emit('end');
+    stream.emit('close');
+  };
+
+  fs.open(options.file, 'a+', '0644', function(err, fd) {
+    if (err) {
+      if (!callback) {
+        stream.emit('error', err);
+      } else {
+        callback(err);
+      }
+      stream.destroy();
+      return;
+    }
+
+    (function read() {
+      if (stream.destroyed) {
+        fs.close(fd);
+        return;
+      }
+
+      return fs.read(fd, buffer, 0, buffer.length, pos, function(err, bytes) {
+        if (err) {
+          if (!callback) {
+            stream.emit('error', err);
+          } else {
+            callback(err);
+          }
+          stream.destroy();
+          return;
+        }
+
+        if (!bytes) {
+          if (buff) {
+            if (options.start == null || row > options.start) {
+              if (!callback) {
+                stream.emit('line', buff);
+              } else {
+                callback(null, buff);
+              }
+            }
+            row++;
+            buff = '';
+          }
+          return setTimeout(read, 1000);
+        }
+
+        var data = decode.write(buffer.slice(0, bytes));
+
+        if (!callback) {
+          stream.emit('data', data);
+        }
+
+        var data = (buff + data).split(/\n+/)
+          , l = data.length - 1
+          , i = 0;
+
+        for (; i < l; i++) {
+          if (options.start == null || row > options.start) {
+            if (!callback) {
+              stream.emit('line', data[i]);
+            } else {
+              callback(null, data[i]);
+            }
+          }
+          row++;
+        }
+
+        buff = data[l];
+
+        pos += bytes;
+
+        return read();
+      });
+    })();
+  });
+
+  if (!callback) {
+    return stream;
+  }
+
+  return stream.destroy;
+};
+
+//
+// ### function stringArrayToSet (array)
+// #### @strArray {Array} Array of Set-elements as strings.
+// #### @errMsg {string} **Optional** Custom error message thrown on invalid input.
+// Returns a Set-like object with strArray's elements as keys (each with the value true).
+//
+exports.stringArrayToSet = function (strArray, errMsg) {
+  if (typeof errMsg === 'undefined') {
+    errMsg = 'Cannot make set from Array with non-string elements';
+  }
+  return strArray.reduce(function (set, el) {
+    if (!(typeof el === 'string' || el instanceof String)) {
+      throw new Error(errMsg);
+    }
+    set[el] = true;
+    return set;
+  }, Object.create(null));
+};