fix

book/node_modules/error/.istanbul.yml

@@ -0,0 +1,11 @@
+instrumentation:
+    default-excludes: false
+    include-all-sources: true
+    excludes:
+        - '**/test/**'
+        - '**/coverage/**'
+        - '**/example/**'
+        - '**/test.js'
+        - '**/node_modules/istanbul/**'
+        - '**/node_modules/tape/**'
+        - '**/node_modules/uber-standard/**'

book/node_modules/error/.npmignore

@@ -0,0 +1,16 @@
+.DS_Store
+.monitor
+.*.swp
+.nodemonignore
+releases
+*.log
+*.err
+fleet.json
+public/browserify
+bin/*.json
+.bin
+build
+compile
+.lock-wscript
+node_modules
+coverage

book/node_modules/error/MIGRATION.md

@@ -0,0 +1,58 @@
+## Migration
+
+## Version 7
+
+The `message` parameter to `TypedError` is now
+required. Previously `message` was optional
+for `TypedError`.
+
+## Version 6
+
+The `WrappedError` class now exposes the error that
+is being wrapped as a `cause` field instead of an
+`original` field.
+
+The following properties have been reserver on the
+wrapped error class: `cause`, `fullType`, `causeMessage`
+
+## Version 5
+
+There were no breaking changes...
+
+## Version 4
+
+The `TypedError` function now has mandatory arguments.
+The `type` and `message` arguments for `TypedError`
+are required.
+
+## Version 3
+
+The `TypedError` class now uses `string-template` for
+message formatting.
+
+Previously:
+
+```js
+var FooError = TypedError({
+  type: 'foo.x'
+  message: 'Got an error %s'
+});
+
+FooError('Oops');
+```
+
+Currently:
+
+```js
+var FooError = TypedError({
+  type: 'foo.x',
+  message: 'Got an error {ctx}',
+  ctx: null
+});
+
+FooError({ ctx: 'Oops' });
+```
+
+## Version 2
+
+Original version

book/node_modules/error/README.md

@@ -0,0 +1,93 @@
+# error
+
+<!--
+    [![build status][1]][2]
+    [![NPM version][3]][4]
+    [![Coverage Status][5]][6]
+    [![gemnasium Dependency Status][7]][8]
+    [![Davis Dependency status][9]][10]
+-->
+
+<!-- [![browser support][11]][12] -->
+
+Custom errors
+
+## Typed Error
+
+```js
+var TypedError = require("error/typed")
+
+var ServerError = TypedError({
+    type: 'server.5xx',
+    message: '{title} server error, status={statusCode}',
+    title: null,
+    statusCode: null
+});
+var ClientError = TypedError({
+    type: 'client.4xx',
+    message: '{title} client error, status={statusCode}',
+    title: null,
+    statusCode: null
+});
+
+var error = ServerError({
+    title:'some title',
+    statusCode: 500
+});
+var error2 = ClientError({
+    title: 'some title',
+    statusCode: 404
+});
+```
+
+## Wrapped Errors
+
+```js
+var net = require('net');
+var WrappedError = require('error/wrapped');
+
+var ServerListenError = WrappedError({
+    message: 'server: {origMessage}',
+    type: 'server.listen-failed',
+    requestedPort: null,
+    host: null
+});
+
+var server = net.createServer();
+
+server.on('error', function onError(err) {
+    if (err.code === 'EADDRINUSE') {
+        throw ServerListenError(err, {
+            requestedPort: 3000,
+            host: null
+        });
+    } else {
+        throw err;
+    }
+});
+
+server.listen(3000);
+```
+
+## Installation
+
+`npm install error`
+
+## Contributors
+
+ - Raynos
+
+## MIT Licenced
+
+  [1]: https://secure.travis-ci.org/Raynos/error.png
+  [2]: https://travis-ci.org/Raynos/error
+  [3]: https://badge.fury.io/js/error.png
+  [4]: https://badge.fury.io/js/error
+  [5]: https://coveralls.io/repos/Raynos/error/badge.png
+  [6]: https://coveralls.io/r/Raynos/error
+  [7]: https://gemnasium.com/Raynos/error.png
+  [8]: https://gemnasium.com/Raynos/error
+  [9]: https://david-dm.org/Raynos/error.png
+  [10]: https://david-dm.org/Raynos/error
+  [11]: https://ci.testling.com/Raynos/error.png
+  [12]: https://ci.testling.com/Raynos/error

book/node_modules/error/docs.mli

@@ -0,0 +1,26 @@
+type OptionError<T> := {
+    option: T | null,
+    message: String,
+    type: "OptionError"
+}
+
+type TypedError<T> := {
+    message: String,
+    type: T
+}
+
+type ValidationError := {
+    errors: Array<Error>,
+    message: String,
+    type: "ValidationError"
+}
+
+error/option := (String, T) => OptionError<T>
+
+error/typed := (args: {
+    message: String,
+    type: String,
+    name?: String
+}) => (opts: Object) => TypedError<String>
+
+error/validation := (Array<Error>) => ValidationError

book/node_modules/error/io.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = IOError;
+
+function IOError(cause, prefix) {
+    var err = new Error(prefix + ': ' + cause.message);
+
+    Object.defineProperty(err, 'type', {
+        value: 'error.IOError',
+        configurable: true,
+        enumerable: true
+    });
+    err.name = 'WrappedIOError';
+    err.statusCode = 500;
+    Object.defineProperty(err, 'cause', {
+        value: cause,
+        configurable: true,
+        enumerable: false
+    });
+    return err;
+}

book/node_modules/error/option.js

@@ -0,0 +1,19 @@
+module.exports = OptionError
+
+function OptionError(message, options) {
+    var result = new Error()
+
+    Object.defineProperty(result, "type", {
+        value: result.type,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    })
+
+    result.option = options || null
+    result.message = message
+    result.type = "OptionError"
+
+    return result
+}
+

book/node_modules/error/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "error",
+  "version": "7.0.2",
+  "description": "Custom errors",
+  "keywords": [],
+  "author": "Raynos <raynos2@gmail.com>",
+  "repository": "git://github.com/Raynos/error.git",
+  "main": "index",
+  "homepage": "https://github.com/Raynos/error",
+  "contributors": [
+    {
+      "name": "Raynos"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/Raynos/error/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "dependencies": {
+    "string-template": "~0.2.1",
+    "xtend": "~4.0.0"
+  },
+  "devDependencies": {
+    "istanbul": "0.3.13",
+    "tape": "^3.5.0",
+    "uber-standard": "3.6.4"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/Raynos/error/raw/master/LICENSE"
+    }
+  ],
+  "scripts": {
+    "lint": "standard -v .",
+    "test": "npm run lint && node test/index.js",
+    "travis-test": "istanbul cover ./test/index.js && ((cat coverage/lcov.info | coveralls) || exit 0)",
+    "cover": "istanbul cover --report none --print detail ./test/index.js",
+    "view-cover": "istanbul report html && google-chrome ./coverage/index.html",
+    "test-browser": "testem-browser ./test/browser/index.js",
+    "testem": "testem-both -b=./test/browser/index.js"
+  },
+  "testling": {
+    "files": "test/index.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}

book/node_modules/error/test/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./typed.js');
+require('./wrapped.js');

book/node_modules/error/test/typed.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var test = require('tape');
+
+var TypedError = require('../typed.js');
+
+test('a server error', function t(assert) {
+    var ServerError = TypedError({
+        type: 'server.5xx.error',
+        message: '{title} server error, status={statusCode}'
+    });
+
+    var error = ServerError({
+        title: 'some title',
+        statusCode: 500
+    });
+
+    assert.equal(ServerError.type, 'server.5xx.error');
+
+    assert.equal(error.type, 'server.5xx.error');
+    assert.equal(error.fullType, 'server.5xx.error');
+    assert.equal(error.statusCode, 500);
+    assert.equal(error.message, 'some title server error, status=500');
+
+    assert.end();
+});
+
+test('a client error', function t(assert) {
+    var ClientError = TypedError({
+        type: 'client.4xx.error',
+        message: '{title} client error, status={statusCode}'
+    });
+
+    var error2 = ClientError({
+        title: 'some title',
+        statusCode: 404
+    });
+
+    assert.equal(error2.type, 'client.4xx.error');
+    assert.equal(error2.fullType, 'client.4xx.error');
+    assert.equal(error2.statusCode, 404);
+    assert.equal(error2.message, 'some title client error, status=404');
+
+    assert.end();
+});

book/node_modules/error/test/wrapped.js

@@ -0,0 +1,182 @@
+'use strict';
+
+var test = require('tape');
+var net = require('net');
+
+var WrappedError = require('../wrapped.js');
+
+test('can create a wrapped error', function t(assert) {
+    var ServerListenError = WrappedError({
+        message: 'server: {causeMessage}',
+        type: 'server.listen-failed',
+        requestedPort: null,
+        host: null
+    });
+
+    var err = new Error('listen EADDRINUSE');
+    err.code = 'EADDRINUSE';
+
+    var err2 = ServerListenError(err, {
+        requestedPort: 3426,
+        host: 'localhost'
+    });
+
+    assert.equal(ServerListenError.type, 'server.listen-failed');
+
+    assert.equal(err2.message, 'server: listen EADDRINUSE');
+    assert.equal(err2.requestedPort, 3426);
+    assert.equal(err2.host, 'localhost');
+    assert.equal(err2.code, 'EADDRINUSE');
+
+    assert.equal(err2.cause, err);
+
+    assert.equal(err2.toString(),
+        'ServerListenFailedError: server: listen EADDRINUSE');
+
+    assert.equal(JSON.stringify(err2), JSON.stringify({
+        type: 'server.listen-failed',
+        message: 'server: listen EADDRINUSE',
+        requestedPort: 3426,
+        host: 'localhost',
+        name: 'ServerListenFailedError',
+        causeMessage: 'listen EADDRINUSE',
+        origMessage: 'listen EADDRINUSE',
+        code: 'EADDRINUSE',
+        fullType: 'server.listen-failed~!~error.wrapped-unknown'
+    }));
+
+    assert.end();
+});
+
+test('can create wrapped error with syscall', function t(assert) {
+    var SysCallError = WrappedError({
+        'message': 'tchannel socket error ({code} from ' +
+            '{syscall}): {origMessage}',
+        type: 'syscall.error'
+    });
+
+    var err = new Error('listen EADDRINUSE');
+    err.code = 'EADDRINUSE';
+    err.syscall = 'listen';
+
+    var err2 = SysCallError(err);
+
+    assert.equal(err2.message, 'tchannel socket error ' +
+        '(EADDRINUSE from listen): listen EADDRINUSE');
+    assert.equal(err2.syscall, 'listen');
+    assert.equal(err2.code, 'EADDRINUSE');
+    assert.equal(err2.type, 'syscall.error');
+
+    assert.end();
+});
+
+test('wrapping twice', function t(assert) {
+    var ReadError = WrappedError({
+        type: 'my.read-error',
+        message: 'read: {causeMessage}'
+    });
+
+    var DatabaseError = WrappedError({
+        type: 'my.database-error',
+        message: 'db: {causeMessage}'
+    });
+
+    var BusinessError = WrappedError({
+        type: 'my.business-error',
+        message: 'business: {causeMessage}'
+    });
+
+    var err = BusinessError(
+        DatabaseError(
+            ReadError(
+                new Error('oops')
+            )
+        )
+    );
+    assert.ok(err);
+
+    assert.equal(err.message, 'business: db: read: oops');
+    assert.equal(err.type, 'my.business-error');
+    assert.equal(err.fullType, 'my.business-error~!~' +
+        'my.database-error~!~' +
+        'my.read-error~!~' +
+        'error.wrapped-unknown');
+
+    assert.end();
+});
+
+test('handles bad recursive strings', function t(assert) {
+    var ReadError = WrappedError({
+        type: 'wat.wat',
+        message: 'read: {causeMessage}'
+    });
+
+    var err2 = ReadError(new Error('hi {causeMessage}'));
+
+    assert.ok(err2);
+    assert.equal(err2.message,
+        'read: hi $INVALID_CAUSE_MESSAGE_LITERAL');
+
+    assert.end();
+});
+
+test('can wrap real IO errors', function t(assert) {
+    var ServerListenError = WrappedError({
+        message: 'server: {causeMessage}',
+        type: 'server.listen-failed',
+        requestedPort: null,
+        host: null
+    });
+
+    var otherServer = net.createServer();
+    otherServer.once('listening', onPortAllocated);
+    otherServer.listen(0);
+
+    function onPortAllocated() {
+        var port = otherServer.address().port;
+
+        var server = net.createServer();
+        server.on('error', onError);
+
+        server.listen(port);
+
+        function onError(cause) {
+            var err = ServerListenError(cause, {
+                host: 'localhost',
+                requestedPort: port
+            });
+
+            otherServer.close();
+            assertOnError(err, cause, port);
+        }
+    }
+
+    function assertOnError(err, cause, port) {
+        assert.equal(err.message, 'server: listen EADDRINUSE');
+        assert.equal(err.requestedPort, port);
+        assert.equal(err.host, 'localhost');
+        assert.equal(err.code, 'EADDRINUSE');
+
+        assert.equal(err.cause, cause);
+
+        assert.equal(err.toString(),
+            'ServerListenFailedError: server: listen EADDRINUSE');
+
+        assert.equal(JSON.stringify(err), JSON.stringify({
+            type: 'server.listen-failed',
+            message: 'server: listen EADDRINUSE',
+            requestedPort: port,
+            host: 'localhost',
+            name: 'ServerListenFailedError',
+            causeMessage: 'listen EADDRINUSE',
+            origMessage: 'listen EADDRINUSE',
+            code: 'EADDRINUSE',
+            errno: 'EADDRINUSE',
+            syscall: 'listen',
+            fullType: 'server.listen-failed~!~' +
+                'error.wrapped-io.listen.EADDRINUSE'
+        }));
+
+        assert.end();
+    }
+});

book/node_modules/error/typed.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var template = require('string-template');
+var extend = require('xtend/mutable');
+var assert = require('assert');
+
+var isWordBoundary = /[_.-](\w|$)/g;
+
+module.exports = TypedError;
+
+function TypedError(args) {
+    assert(args, 'TypedError: must specify options');
+    assert(args.type, 'TypedError: must specify options.type');
+    assert(args.message, 'TypedError: must specify options.message');
+
+    assert(!has(args, 'fullType'),
+        'TypedError: fullType field is reserved');
+
+    var message = args.message;
+    if (args.type && !args.name) {
+        var errorName = camelCase(args.type) + 'Error';
+        args.name = errorName[0].toUpperCase() + errorName.substr(1);
+    }
+
+    extend(createError, args);
+    createError._name = args.name;
+
+    return createError;
+
+    function createError(opts) {
+        var result = new Error();
+
+        Object.defineProperty(result, 'type', {
+            value: result.type,
+            enumerable: true,
+            writable: true,
+            configurable: true
+        });
+
+        var options = extend({}, args, opts);
+        if (!options.fullType) {
+            options.fullType = options.type;
+        }
+
+        extend(result, options);
+        if (opts && opts.message) {
+            result.message = template(opts.message, options);
+        } else if (message) {
+            result.message = template(message, options);
+        }
+
+        return result;
+    }
+}
+
+function camelCase(str) {
+    return str.replace(isWordBoundary, upperCase);
+}
+
+function upperCase(_, x) {
+    return x.toUpperCase();
+}
+
+function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

book/node_modules/error/validation.js

@@ -0,0 +1,19 @@
+module.exports = ValidationError
+
+function ValidationError(errors) {
+    var result = new Error()
+
+    Object.defineProperty(result, "type", {
+        value: result.type,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    })
+
+    result.errors = errors
+    result.message = errors[0].message
+    result.type = "ValidationError"
+
+    return result
+}
+

book/node_modules/error/wrapped.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var extend = require('xtend/mutable');
+var assert = require('assert');
+
+var TypedError = require('./typed.js');
+
+var objectToString = Object.prototype.toString;
+var ERROR_TYPE = '[object Error]';
+var causeMessageRegex = /\{causeMessage\}/g;
+var origMessageRegex = /\{origMessage\}/g;
+
+module.exports = WrappedError;
+
+function WrappedError(options) {
+    assert(options, 'WrappedError: must specify options');
+    assert(options.type, 'WrappedError: must specify type');
+    assert(options.message, 'WrappedError: must specify message');
+
+    assert(!has(options, 'cause'),
+        'WrappedError: cause field is reserved');
+    assert(!has(options, 'fullType'),
+        'WrappedError: fullType field is reserved');
+    assert(!has(options, 'causeMessage'),
+        'WrappedError: causeMessage field is reserved');
+    assert(!has(options, 'origMessage'),
+        'WrappedError: origMessage field is reserved');
+
+    var createTypedError = TypedError(options);
+    extend(createError, options);
+    createError._name = options.name;
+
+    return createError;
+
+    function createError(cause, opts) {
+        /*eslint max-statements: [2, 25]*/
+        assert(cause, 'an error is required');
+        assert(isError(cause),
+            'WrappedError: first argument must be an error');
+
+        var causeMessage = cause.message;
+        if (causeMessage.indexOf('{causeMessage}') >= 0) {
+            // recover
+            causeMessage = causeMessage.replace(
+                causeMessageRegex,
+                '$INVALID_CAUSE_MESSAGE_LITERAL'
+            );
+        }
+        if (causeMessage.indexOf('{origMessage}') >= 0) {
+            causeMessage = causeMessage.replace(
+                origMessageRegex,
+                '$INVALID_ORIG_MESSAGE_LITERAL'
+            );
+        }
+
+        var nodeCause = false;
+        var errOptions = extend({}, opts, {
+            causeMessage: causeMessage,
+            origMessage: causeMessage
+        });
+
+        if (has(cause, 'code') && !has(errOptions, 'code')) {
+            errOptions.code = cause.code;
+        }
+
+        if (has(cause, 'errno') && !has(errOptions, 'errno')) {
+            errOptions.errno = cause.errno;
+            nodeCause = true;
+        }
+
+        if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
+            errOptions.syscall = cause.syscall;
+            nodeCause = true;
+        }
+
+        var causeType = cause.type;
+        if (!causeType && nodeCause) {
+            causeType = 'error.wrapped-io.' +
+                (cause.syscall || 'unknown') + '.' +
+                (cause.errno || 'unknown');
+        } else {
+            causeType = 'error.wrapped-unknown';
+        }
+
+        errOptions.fullType = options.type + '~!~' +
+            (cause.fullType || cause.type || causeType);
+
+        var err = createTypedError(errOptions);
+
+        Object.defineProperty(err, 'cause', {
+            value: cause,
+            configurable: true,
+            enumerable: false
+        });
+        return err;
+    }
+}
+
+function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isError(err) {
+    return objectToString.call(err) === ERROR_TYPE;
+}