passenger 5.0.21 → 5.0.22

data/src/nodejs_supportlib/vendor-copy/winston/node_modules/cycle/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cycle",
+  "description": "decycle your json",
+  "author": "",
+  "version": "1.0.3",
+  "main": "./cycle.js",
+  "homepage": "https://github.com/douglascrockford/JSON-js",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/dscape/cycle.git"
+  },
+  "bugs": {
+    "url": "http://github.com/douglascrockford/JSON-js/issues"
+  },
+  "keywords": [
+    "json",
+    "cycle",
+    "stringify",
+    "parse"
+  ],
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "readme": "Fork of https://github.com/douglascrockford/JSON-js, maintained in npm as `cycle`.\n\n# Contributors\n\n* Douglas Crockford\n* Nuno Job\n* Justin Warkentin\n\n# JSON in JavaScript\n\nDouglas Crockford\ndouglas@crockford.com\n\n2010-11-18\n\n\nJSON is a light-weight, language independent, data interchange format.\nSee http://www.JSON.org/\n\nThe files in this collection implement JSON encoders/decoders in JavaScript.\n\nJSON became a built-in feature of JavaScript when the ECMAScript Programming\nLanguage Standard - Fifth Edition was adopted by the ECMA General Assembly\nin December 2009. Most of the files in this collection are for applications\nthat are expected to run in obsolete web browsers. For most purposes, json2.js\nis the best choice.\n\n\njson2.js: This file creates a JSON property in the global object, if there\nisn't already one, setting its value to an object containing a stringify\nmethod and a parse method. The parse method uses the eval method to do the\nparsing, guarding it with several regular expressions to defend against\naccidental code execution hazards. On current browsers, this file does nothing,\nprefering the built-in JSON object.\n\njson.js: This file does everything that json2.js does. It also adds a\ntoJSONString method and a parseJSON method to Object.prototype. Use of this\nfile is not recommended.\n\njson_parse.js: This file contains an alternative JSON parse function that\nuses recursive descent instead of eval.\n\njson_parse_state.js: This files contains an alternative JSON parse function that\nuses a state machine instead of eval.\n\ncycle.js: This file contains two functions, JSON.decycle and JSON.retrocycle,\nwhich make it possible to encode cyclical structures and dags in JSON, and to\nthen recover them. JSONPath is used to represent the links.\nhttp://GOESSNER.net/articles/JsonPath/\n",
+  "readmeFilename": "README.md",
+  "_id": "cycle@1.0.3",
+  "_shasum": "21e80b2be8580f98b468f379430662b046c34ad2",
+  "_from": "cycle@1.0.x",
+  "_resolved": "https://registry.npmjs.org/cycle/-/cycle-1.0.3.tgz"
+}

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

@@ -0,0 +1,20 @@
+Copyright (c) 2009 cloudhead
+
+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/node_modules/eyes/lib/eyes.js

@@ -0,0 +1,236 @@
+//
+// Eyes.js - a customizable value inspector for Node.js
+//
+//   usage:
+//
+//       var inspect = require('eyes').inspector({styles: {all: 'magenta'}});
+//       inspect(something); // inspect with the settings passed to `inspector`
+//
+//     or
+//
+//       var eyes = require('eyes');
+//       eyes.inspect(something); // inspect with the default settings
+//
+var eyes = exports,
+    stack = [];
+
+eyes.defaults = {
+    styles: {                 // Styles applied to stdout
+        all:     'cyan',      // Overall style applied to everything
+        label:   'underline', // Inspection labels, like 'array' in `array: [1, 2, 3]`
+        other:   'inverted',  // Objects which don't have a literal representation, such as functions
+        key:     'bold',      // The keys in object literals, like 'a' in `{a: 1}`
+        special: 'grey',      // null, undefined...
+        string:  'green',
+        number:  'magenta',
+        bool:    'blue',      // true false
+        regexp:  'green',     // /\d+/
+    },
+    pretty: true,             // Indent object literals
+    hideFunctions: false,
+    showHidden: false,
+    stream: process.stdout,
+    maxLength: 2048           // Truncate output if longer
+};
+
+// Return a curried inspect() function, with the `options` argument filled in.
+eyes.inspector = function (options) {
+    var that = this;
+    return function (obj, label, opts) {
+        return that.inspect.call(that, obj, label,
+            merge(options || {}, opts || {}));
+    };
+};
+
+// If we have a `stream` defined, use it to print a styled string,
+// if not, we just return the stringified object.
+eyes.inspect = function (obj, label, options) {
+    options = merge(this.defaults, options || {});
+
+    if (options.stream) {
+        return this.print(stringify(obj, options), label, options);
+    } else {
+        return stringify(obj, options) + (options.styles ? '\033[39m' : '');
+    }
+};
+
+// Output using the 'stream', and an optional label
+// Loop through `str`, and truncate it after `options.maxLength` has been reached.
+// Because escape sequences are, at this point embeded within
+// the output string, we can't measure the length of the string
+// in a useful way, without separating what is an escape sequence,
+// versus a printable character (`c`). So we resort to counting the
+// length manually.
+eyes.print = function (str, label, options) {
+    for (var c = 0, i = 0; i < str.length; i++) {
+        if (str.charAt(i) === '\033') { i += 4 } // `4` because '\033[25m'.length + 1 == 5
+        else if (c === options.maxLength) {
+           str = str.slice(0, i - 1) + '…';
+           break;
+        } else { c++ }
+    }
+    return options.stream.write.call(options.stream, (label ?
+        this.stylize(label, options.styles.label, options.styles) + ': ' : '') +
+        this.stylize(str,   options.styles.all, options.styles) + '\033[0m' + "\n");
+};
+
+// Apply a style to a string, eventually,
+// I'd like this to support passing multiple
+// styles.
+eyes.stylize = function (str, style, styles) {
+    var codes = {
+        'bold'      : [1,  22],
+        'underline' : [4,  24],
+        'inverse'   : [7,  27],
+        'cyan'      : [36, 39],
+        'magenta'   : [35, 39],
+        'blue'      : [34, 39],
+        'yellow'    : [33, 39],
+        'green'     : [32, 39],
+        'red'       : [31, 39],
+        'grey'      : [90, 39]
+    }, endCode;
+
+    if (style && codes[style]) {
+        endCode = (codes[style][1] === 39 && styles.all) ? codes[styles.all][0]
+                                                         : codes[style][1];
+        return '\033[' + codes[style][0] + 'm' + str +
+               '\033[' + endCode + 'm';
+    } else { return str }
+};
+
+// Convert any object to a string, ready for output.
+// When an 'array' or an 'object' are encountered, they are
+// passed to specialized functions, which can then recursively call
+// stringify().
+function stringify(obj, options) {
+    var that = this, stylize = function (str, style) {
+        return eyes.stylize(str, options.styles[style], options.styles)
+    }, index, result;
+
+    if ((index = stack.indexOf(obj)) !== -1) {
+        return stylize(new(Array)(stack.length - index + 1).join('.'), 'special');
+    }
+    stack.push(obj);
+
+    result = (function (obj) {
+        switch (typeOf(obj)) {
+            case "string"   : obj = stringifyString(obj.indexOf("'") === -1 ? "'" + obj + "'"
+                                                                            : '"' + obj + '"');
+                              return stylize(obj, 'string');
+            case "regexp"   : return stylize('/' + obj.source + '/', 'regexp');
+            case "number"   : return stylize(obj + '',    'number');
+            case "function" : return options.stream ? stylize("Function", 'other') : '[Function]';
+            case "null"     : return stylize("null",      'special');
+            case "undefined": return stylize("undefined", 'special');
+            case "boolean"  : return stylize(obj + '',    'bool');
+            case "date"     : return stylize(obj.toUTCString());
+            case "array"    : return stringifyArray(obj,  options, stack.length);
+            case "object"   : return stringifyObject(obj, options, stack.length);
+        }
+    })(obj);
+
+    stack.pop();
+    return result;
+};
+
+// Escape invisible characters in a string
+function stringifyString (str, options) {
+    return str.replace(/\\/g, '\\\\')
+              .replace(/\n/g, '\\n')
+              .replace(/[\u0001-\u001F]/g, function (match) {
+                  return '\\0' + match[0].charCodeAt(0).toString(8);
+              });
+}
+
+// Convert an array to a string, such as [1, 2, 3].
+// This function calls stringify() for each of the elements
+// in the array.
+function stringifyArray(ary, options, level) {
+    var out = [];
+    var pretty = options.pretty && (ary.length > 4 || ary.some(function (o) {
+        return (o !== null && typeof(o) === 'object' && Object.keys(o).length > 0) ||
+               (Array.isArray(o) && o.length > 0);
+    }));
+    var ws = pretty ? '\n' + new(Array)(level * 4 + 1).join(' ') : ' ';
+
+    for (var i = 0; i < ary.length; i++) {
+        out.push(stringify(ary[i], options));
+    }
+
+    if (out.length === 0) {
+        return '[]';
+    } else {
+        return '[' + ws
+                   + out.join(',' + (pretty ? ws : ' '))
+                   + (pretty ? ws.slice(0, -4) : ws) +
+               ']';
+    }
+};
+
+// Convert an object to a string, such as {a: 1}.
+// This function calls stringify() for each of its values,
+// and does not output functions or prototype values.
+function stringifyObject(obj, options, level) {
+    var out = [];
+    var pretty = options.pretty && (Object.keys(obj).length > 2 ||
+                                    Object.keys(obj).some(function (k) { return typeof(obj[k]) === 'object' }));
+    var ws = pretty ? '\n' + new(Array)(level * 4 + 1).join(' ') : ' ';
+
+    var keys = options.showHidden ? Object.keys(obj) : Object.getOwnPropertyNames(obj);
+    keys.forEach(function (k) {
+        if (Object.prototype.hasOwnProperty.call(obj, k) 
+          && !(obj[k] instanceof Function && options.hideFunctions)) {
+            out.push(eyes.stylize(k, options.styles.key, options.styles) + ': ' +
+                     stringify(obj[k], options));
+        }
+    });
+
+    if (out.length === 0) {
+        return '{}';
+    } else {
+        return "{" + ws
+                   + out.join(',' + (pretty ? ws : ' '))
+                   + (pretty ? ws.slice(0, -4) : ws) +
+               "}";
+   }
+};
+
+// A better `typeof`
+function typeOf(value) {
+    var s = typeof(value),
+        types = [Object, Array, String, RegExp, Number, Function, Boolean, Date];
+
+    if (s === 'object' || s === 'function') {
+        if (value) {
+            types.forEach(function (t) {
+                if (value instanceof t) { s = t.name.toLowerCase() }
+            });
+        } else { s = 'null' }
+    }
+    return s;
+}
+
+function merge(/* variable args */) {
+    var objs = Array.prototype.slice.call(arguments);
+    var target = {};
+
+    objs.forEach(function (o) {
+        Object.keys(o).forEach(function (k) {
+            if (k === 'styles') {
+                if (! o.styles) {
+                    target.styles = false;
+                } else {
+                    target.styles = {}
+                    for (var s in o.styles) {
+                        target.styles[s] = o.styles[s];
+                    }
+                }
+            } else {
+                target[k] = o[k];
+            }
+        });
+    });
+    return target;
+}
+

data/src/nodejs_supportlib/vendor-copy/winston/node_modules/eyes/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "eyes",
+  "description": "a customizable value inspector",
+  "url": "http://github.com/cloudhead/eyes.js",
+  "keywords": [
+    "inspector",
+    "debug",
+    "inspect",
+    "print"
+  ],
+  "author": {
+    "name": "Alexis Sellier",
+    "email": "self@cloudhead.net"
+  },
+  "contributors": [
+    {
+      "name": "Charlie Robbins",
+      "email": "charlie@nodejitsu.com"
+    }
+  ],
+  "licenses": [
+    "MIT"
+  ],
+  "main": "./lib/eyes",
+  "version": "0.1.8",
+  "scripts": {
+    "test": "node test/*-test.js"
+  },
+  "directories": {
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "engines": {
+    "node": "> 0.1.90"
+  },
+  "readme": "eyes\n====\n\na customizable value inspector for Node.js\n\nsynopsis\n--------\n\nI was tired of looking at cluttered output in the console -- something needed to be done,\n`sys.inspect()` didn't display regexps correctly, and was too verbose, and I had an hour or two to spare. \nSo I decided to have some fun. _eyes_ were born.\n\n![eyes-ss](http://dl.dropbox.com/u/251849/eyes-js-ss.gif)\n\n_example of the output of a user-customized eyes.js inspector_\n\n*eyes* also deals with circular objects in an intelligent way, and can pretty-print object literals.\n\nusage\n-----\n\n    var inspect = require('eyes').inspector({styles: {all: 'magenta'}});\n\n    inspect(something); // inspect with the settings passed to `inspector`\n\nor\n\n    var eyes = require('eyes');\n\n    eyes.inspect(something); // inspect with the default settings\n\nyou can pass a _label_ to `inspect()`, to keep track of your inspections:\n\n    eyes.inspect(something, \"a random value\");\n\nIf you want to return the output of eyes without printing it, you can set it up this way:\n\n    var inspect = require('eyes').inspector({ stream: null });\n\n    sys.puts(inspect({ something: 42 }));\n\ncustomization\n-------------\n\nThese are the default styles and settings used by _eyes_.\n\n    styles: {                 // Styles applied to stdout\n        all:     'cyan',      // Overall style applied to everything\n        label:   'underline', // Inspection labels, like 'array' in `array: [1, 2, 3]`\n        other:   'inverted',  // Objects which don't have a literal representation, such as functions\n        key:     'bold',      // The keys in object literals, like 'a' in `{a: 1}`\n        special: 'grey',      // null, undefined...\n        string:  'green',\n        number:  'magenta',\n        bool:    'blue',      // true false\n        regexp:  'green',     // /\\d+/\n    },\n    \n    pretty: true,             // Indent object literals\n    hideFunctions: false,     // Don't output functions at all\n    stream: process.stdout,   // Stream to write to, or null\n    maxLength: 2048           // Truncate output if longer\n\nYou can overwrite them with your own, by passing a similar object to `inspector()` or `inspect()`.\n\n    var inspect = require('eyes').inspector({\n        styles: {\n            all: 'magenta',\n            special: 'bold'\n        },\n        maxLength: 512\n    });\n\n",
+  "readmeFilename": "README.md",
+  "_id": "eyes@0.1.8",
+  "_shasum": "62cf120234c683785d902348a800ef3e0cc20bc0",
+  "_from": "eyes@0.1.x",
+  "_resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/winston/node_modules/isstream/LICENSE.md

@@ -0,0 +1,11 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2015 Rod Vagg
+---------------------------
+
+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/node_modules/isstream/isstream.js

@@ -0,0 +1,27 @@
+var stream = require('stream')
+
+
+function isStream (obj) {
+  return obj instanceof stream.Stream
+}
+
+
+function isReadable (obj) {
+  return isStream(obj) && typeof obj._read == 'function' && typeof obj._readableState == 'object'
+}
+
+
+function isWritable (obj) {
+  return isStream(obj) && typeof obj._write == 'function' && typeof obj._writableState == 'object'
+}
+
+
+function isDuplex (obj) {
+  return isReadable(obj) && isWritable(obj)
+}
+
+
+module.exports            = isStream
+module.exports.isReadable = isReadable
+module.exports.isWritable = isWritable
+module.exports.isDuplex   = isDuplex

data/src/nodejs_supportlib/vendor-copy/winston/node_modules/isstream/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "isstream",
+  "version": "0.1.2",
+  "description": "Determine if an object is a Stream",
+  "main": "isstream.js",
+  "scripts": {
+    "test": "tar --xform 's/^package/readable-stream-1.0/' -zxf readable-stream-1.0.*.tgz && tar --xform 's/^package/readable-stream-1.1/' -zxf readable-stream-1.1.*.tgz && node test.js; rm -rf readable-stream-1.?/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rvagg/isstream.git"
+  },
+  "keywords": [
+    "stream",
+    "type",
+    "streams",
+    "readable-stream",
+    "hippo"
+  ],
+  "devDependencies": {
+    "tape": "~2.12.3",
+    "core-util-is": "~1.0.0",
+    "isarray": "0.0.1",
+    "string_decoder": "~0.10.x",
+    "inherits": "~2.0.1"
+  },
+  "author": {
+    "name": "Rod Vagg",
+    "email": "rod@vagg.org"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rvagg/isstream/issues"
+  },
+  "homepage": "https://github.com/rvagg/isstream",
+  "readme": "# isStream\n\n[![Build Status](https://secure.travis-ci.org/rvagg/isstream.png)](http://travis-ci.org/rvagg/isstream)\n\n**Test if an object is a `Stream`**\n\n[![NPM](https://nodei.co/npm/isstream.svg)](https://nodei.co/npm/isstream/)\n\nThe missing `Stream.isStream(obj)`: determine if an object is standard Node.js `Stream`. Works for Node-core `Stream` objects (for 0.8, 0.10, 0.11, and in theory, older and newer versions) and all versions of **[readable-stream](https://github.com/isaacs/readable-stream)**.\n\n## Usage:\n\n```js\nvar isStream = require('isstream')\nvar Stream = require('stream')\n\nisStream(new Stream()) // true\n\nisStream({}) // false\n\nisStream(new Stream.Readable())    // true\nisStream(new Stream.Writable())    // true\nisStream(new Stream.Duplex())      // true\nisStream(new Stream.Transform())   // true\nisStream(new Stream.PassThrough()) // true\n```\n\n## But wait! There's more!\n\nYou can also test for `isReadable(obj)`, `isWritable(obj)` and `isDuplex(obj)` to test for implementations of Streams2 (and Streams3) base classes.\n\n```js\nvar isReadable = require('isstream').isReadable\nvar isWritable = require('isstream').isWritable\nvar isDuplex = require('isstream').isDuplex\nvar Stream = require('stream')\n\nisReadable(new Stream()) // false\nisWritable(new Stream()) // false\nisDuplex(new Stream())   // false\n\nisReadable(new Stream.Readable())    // true\nisReadable(new Stream.Writable())    // false\nisReadable(new Stream.Duplex())      // true\nisReadable(new Stream.Transform())   // true\nisReadable(new Stream.PassThrough()) // true\n\nisWritable(new Stream.Readable())    // false\nisWritable(new Stream.Writable())    // true\nisWritable(new Stream.Duplex())      // true\nisWritable(new Stream.Transform())   // true\nisWritable(new Stream.PassThrough()) // true\n\nisDuplex(new Stream.Readable())    // false\nisDuplex(new Stream.Writable())    // false\nisDuplex(new Stream.Duplex())      // true\nisDuplex(new Stream.Transform())   // true\nisDuplex(new Stream.PassThrough()) // true\n```\n\n*Reminder: when implementing your own streams, please [use **readable-stream** rather than core streams](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).*\n\n\n## License\n\n**isStream** is Copyright (c) 2015 Rod Vagg [@rvagg](https://twitter.com/rvagg) and licenced under the MIT licence. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE.md file for more details.\n",
+  "readmeFilename": "README.md",
+  "_id": "isstream@0.1.2",
+  "_shasum": "47e63f7af55afa6f92e1500e690eb8b8529c099a",
+  "_from": "isstream@0.1.x",
+  "_resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/winston/node_modules/pkginfo/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/node_modules/pkginfo/lib/pkginfo.js

@@ -0,0 +1,136 @@
+/*
+ * pkginfo.js: Top-level include for the pkginfo module
+ *
+ * (C) 2011, Charlie Robbins
+ *
+ */
+ 
+var fs = require('fs'),
+    path = require('path');
+
+//
+// ### function pkginfo ([options, 'property', 'property' ..])
+// #### @pmodule {Module} Parent module to read from.
+// #### @options {Object|Array|string} **Optional** Options used when exposing properties.
+// #### @arguments {string...} **Optional** Specified properties to expose.
+// Exposes properties from the package.json file for the parent module on 
+// it's exports. Valid usage:
+//
+// `require('pkginfo')()`
+//
+// `require('pkginfo')('version', 'author');`
+//
+// `require('pkginfo')(['version', 'author']);`
+//
+// `require('pkginfo')({ include: ['version', 'author'] });`
+//
+var pkginfo = module.exports = function (pmodule, options) {
+  var args = [].slice.call(arguments, 2).filter(function (arg) {
+    return typeof arg === 'string';
+  });
+  
+  //
+  // **Parse variable arguments**
+  //
+  if (Array.isArray(options)) {
+    //
+    // If the options passed in is an Array assume that
+    // it is the Array of properties to expose from the
+    // on the package.json file on the parent module.
+    //
+    options = { include: options };
+  }
+  else if (typeof options === 'string') {
+    //
+    // Otherwise if the first argument is a string, then
+    // assume that it is the first property to expose from
+    // the package.json file on the parent module.
+    //
+    options = { include: [options] };
+  }
+  
+  //
+  // **Setup default options**
+  //
+  options = options || {};
+  
+  // ensure that includes have been defined
+  options.include = options.include || [];
+  
+  if (args.length > 0) {
+    //
+    // If additional string arguments have been passed in
+    // then add them to the properties to expose on the 
+    // parent module. 
+    //
+    options.include = options.include.concat(args);
+  }
+  
+  var pkg = pkginfo.read(pmodule, options.dir).package;
+  Object.keys(pkg).forEach(function (key) {
+    if (options.include.length > 0 && !~options.include.indexOf(key)) {
+      return;
+    }
+    
+    if (!pmodule.exports[key]) {
+      pmodule.exports[key] = pkg[key];
+    }
+  });
+  
+  return pkginfo;
+};
+
+//
+// ### function find (dir)
+// #### @pmodule {Module} Parent module to read from.
+// #### @dir {string} **Optional** Directory to start search from.
+// Searches up the directory tree from `dir` until it finds a directory
+// which contains a `package.json` file. 
+//
+pkginfo.find = function (pmodule, dir) {
+  if (! dir) {
+    dir = path.dirname(pmodule.filename);
+  }
+  
+  var files = fs.readdirSync(dir);
+  
+  if (~files.indexOf('package.json')) {
+    return path.join(dir, 'package.json');
+  }
+  
+  if (dir === '/') {
+    throw new Error('Could not find package.json up from: ' + dir);
+  }
+  else if (!dir || dir === '.') {
+    throw new Error('Cannot find package.json from unspecified directory');
+  }
+  
+  return pkginfo.find(pmodule, path.dirname(dir));
+};
+
+//
+// ### function read (pmodule, dir)
+// #### @pmodule {Module} Parent module to read from.
+// #### @dir {string} **Optional** Directory to start search from.
+// Searches up the directory tree from `dir` until it finds a directory
+// which contains a `package.json` file and returns the package information.
+//
+pkginfo.read = function (pmodule, dir) { 
+  dir = pkginfo.find(pmodule, dir);
+  
+  var data = fs.readFileSync(dir).toString();
+      
+  return {
+    dir: dir, 
+    package: JSON.parse(data)
+  };
+};
+
+//
+// Call `pkginfo` on this module and expose version.
+//
+pkginfo(module, {
+  dir: __dirname,
+  include: ['version'],
+  target: pkginfo
+});