postdoc 0.1.2 → 0.2.0.beta4

data/node_modules/es6-promise/lib/es6-promise/promise.js

@@ -0,0 +1,427 @@
+import {
+  isFunction
+} from './utils';
+import {
+  noop,
+  nextId,
+  PROMISE_ID,
+  initializePromise
+} from './-internal';
+import {
+  asap,
+  setAsap,
+  setScheduler
+} from './asap';
+
+import all from './promise/all';
+import race from './promise/race';
+import Resolve from './promise/resolve';
+import Reject from './promise/reject';
+import then from './then';
+
+function needsResolver() {
+  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+}
+
+function needsNew() {
+  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+}
+
+/**
+  Promise objects represent the eventual result of an asynchronous operation. The
+  primary way of interacting with a promise is through its `then` method, which
+  registers callbacks to receive either a promise's eventual value or the reason
+  why the promise cannot be fulfilled.
+
+  Terminology
+  -----------
+
+  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+  - `thenable` is an object or function that defines a `then` method.
+  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+  - `exception` is a value that is thrown using the throw statement.
+  - `reason` is a value that indicates why a promise was rejected.
+  - `settled` the final resting state of a promise, fulfilled or rejected.
+
+  A promise can be in one of three states: pending, fulfilled, or rejected.
+
+  Promises that are fulfilled have a fulfillment value and are in the fulfilled
+  state.  Promises that are rejected have a rejection reason and are in the
+  rejected state.  A fulfillment value is never a thenable.
+
+  Promises can also be said to *resolve* a value.  If this value is also a
+  promise, then the original promise's settled state will match the value's
+  settled state.  So a promise that *resolves* a promise that rejects will
+  itself reject, and a promise that *resolves* a promise that fulfills will
+  itself fulfill.
+
+
+  Basic Usage:
+  ------------
+
+  ```js
+  let promise = new Promise(function(resolve, reject) {
+    // on success
+    resolve(value);
+
+    // on failure
+    reject(reason);
+  });
+
+  promise.then(function(value) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Advanced Usage:
+  ---------------
+
+  Promises shine when abstracting away asynchronous interactions such as
+  `XMLHttpRequest`s.
+
+  ```js
+  function getJSON(url) {
+    return new Promise(function(resolve, reject){
+      let xhr = new XMLHttpRequest();
+
+      xhr.open('GET', url);
+      xhr.onreadystatechange = handler;
+      xhr.responseType = 'json';
+      xhr.setRequestHeader('Accept', 'application/json');
+      xhr.send();
+
+      function handler() {
+        if (this.readyState === this.DONE) {
+          if (this.status === 200) {
+            resolve(this.response);
+          } else {
+            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+          }
+        }
+      };
+    });
+  }
+
+  getJSON('/posts.json').then(function(json) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Unlike callbacks, promises are great composable primitives.
+
+  ```js
+  Promise.all([
+    getJSON('/posts'),
+    getJSON('/comments')
+  ]).then(function(values){
+    values[0] // => postsJSON
+    values[1] // => commentsJSON
+
+    return values;
+  });
+  ```
+
+  @class Promise
+  @param {Function} resolver
+  Useful for tooling.
+  @constructor
+*/
+
+class Promise {
+  constructor(resolver) {
+    this[PROMISE_ID] = nextId();
+    this._result = this._state = undefined;
+    this._subscribers = [];
+
+    if (noop !== resolver) {
+      typeof resolver !== 'function' && needsResolver();
+      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
+    }
+  }
+
+  /**
+  The primary way of interacting with a promise is through its `then` method,
+  which registers callbacks to receive either a promise's eventual value or the
+  reason why the promise cannot be fulfilled.
+
+  ```js
+  findUser().then(function(user){
+    // user is available
+  }, function(reason){
+    // user is unavailable, and you are given the reason why
+  });
+  ```
+
+  Chaining
+  --------
+
+  The return value of `then` is itself a promise.  This second, 'downstream'
+  promise is resolved with the return value of the first promise's fulfillment
+  or rejection handler, or rejected if the handler throws an exception.
+
+  ```js
+  findUser().then(function (user) {
+    return user.name;
+  }, function (reason) {
+    return 'default name';
+  }).then(function (userName) {
+    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+    // will be `'default name'`
+  });
+
+  findUser().then(function (user) {
+    throw new Error('Found user, but still unhappy');
+  }, function (reason) {
+    throw new Error('`findUser` rejected and we're unhappy');
+  }).then(function (value) {
+    // never reached
+  }, function (reason) {
+    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+  });
+  ```
+  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+
+  ```js
+  findUser().then(function (user) {
+    throw new PedagogicalException('Upstream error');
+  }).then(function (value) {
+    // never reached
+  }).then(function (value) {
+    // never reached
+  }, function (reason) {
+    // The `PedgagocialException` is propagated all the way down to here
+  });
+  ```
+
+  Assimilation
+  ------------
+
+  Sometimes the value you want to propagate to a downstream promise can only be
+  retrieved asynchronously. This can be achieved by returning a promise in the
+  fulfillment or rejection handler. The downstream promise will then be pending
+  until the returned promise is settled. This is called *assimilation*.
+
+  ```js
+  findUser().then(function (user) {
+    return findCommentsByAuthor(user);
+  }).then(function (comments) {
+    // The user's comments are now available
+  });
+  ```
+
+  If the assimliated promise rejects, then the downstream promise will also reject.
+
+  ```js
+  findUser().then(function (user) {
+    return findCommentsByAuthor(user);
+  }).then(function (comments) {
+    // If `findCommentsByAuthor` fulfills, we'll have the value here
+  }, function (reason) {
+    // If `findCommentsByAuthor` rejects, we'll have the reason here
+  });
+  ```
+
+  Simple Example
+  --------------
+
+  Synchronous Example
+
+  ```javascript
+  let result;
+
+  try {
+    result = findResult();
+    // success
+  } catch(reason) {
+    // failure
+  }
+  ```
+
+  Errback Example
+
+  ```js
+  findResult(function(result, err){
+    if (err) {
+      // failure
+    } else {
+      // success
+    }
+  });
+  ```
+
+  Promise Example;
+
+  ```javascript
+  findResult().then(function(result){
+    // success
+  }, function(reason){
+    // failure
+  });
+  ```
+
+  Advanced Example
+  --------------
+
+  Synchronous Example
+
+  ```javascript
+  let author, books;
+
+  try {
+    author = findAuthor();
+    books  = findBooksByAuthor(author);
+    // success
+  } catch(reason) {
+    // failure
+  }
+  ```
+
+  Errback Example
+
+  ```js
+
+  function foundBooks(books) {
+
+  }
+
+  function failure(reason) {
+
+  }
+
+  findAuthor(function(author, err){
+    if (err) {
+      failure(err);
+      // failure
+    } else {
+      try {
+        findBoooksByAuthor(author, function(books, err) {
+          if (err) {
+            failure(err);
+          } else {
+            try {
+              foundBooks(books);
+            } catch(reason) {
+              failure(reason);
+            }
+          }
+        });
+      } catch(error) {
+        failure(err);
+      }
+      // success
+    }
+  });
+  ```
+
+  Promise Example;
+
+  ```javascript
+  findAuthor().
+    then(findBooksByAuthor).
+    then(function(books){
+      // found books
+  }).catch(function(reason){
+    // something went wrong
+  });
+  ```
+
+  @method then
+  @param {Function} onFulfilled
+  @param {Function} onRejected
+  Useful for tooling.
+  @return {Promise}
+  */
+
+    /**
+  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+  as the catch block of a try/catch statement.
+
+  ```js
+  function findAuthor(){
+    throw new Error('couldn't find that author');
+  }
+
+  // synchronous
+  try {
+    findAuthor();
+  } catch(reason) {
+    // something went wrong
+  }
+
+  // async with promises
+  findAuthor().catch(function(reason){
+    // something went wrong
+  });
+  ```
+
+  @method catch
+  @param {Function} onRejection
+  Useful for tooling.
+  @return {Promise}
+  */
+  catch(onRejection) {
+    return this.then(null, onRejection);
+  }
+
+/**
+  `finally` will be invoked regardless of the promise's fate just as native
+  try/catch/finally behaves
+
+  Synchronous example:
+
+  ```js
+  findAuthor() {
+    if (Math.random() > 0.5) {
+      throw new Error();
+    }
+    return new Author();
+  }
+
+  try {
+    return findAuthor(); // succeed or fail
+  } catch(error) {
+    return findOtherAuther();
+  } finally {
+    // always runs
+    // doesn't affect the return value
+  }
+  ```
+
+  Asynchronous example:
+
+  ```js
+  findAuthor().catch(function(reason){
+    return findOtherAuther();
+  }).finally(function(){
+    // author was either found, or not
+  });
+  ```
+
+  @method finally
+  @param {Function} callback
+  @return {Promise}
+*/
+  finally(callback) {
+    let promise = this;
+    let constructor = promise.constructor;
+
+    return promise.then(value => constructor.resolve(callback()).then(() => value),
+                       reason => constructor.resolve(callback()).then(() => { throw reason; }));
+  }
+}
+
+Promise.prototype.then = then;
+export default Promise;
+Promise.all = all;
+Promise.race = race;
+Promise.resolve = Resolve;
+Promise.reject = Reject;
+Promise._setScheduler = setScheduler;
+Promise._setAsap = setAsap;
+Promise._asap = asap;
+

data/node_modules/es6-promise/lib/es6-promise/then.js

@@ -0,0 +1,32 @@
+import {
+  invokeCallback,
+  subscribe,
+  FULFILLED,
+  REJECTED,
+  noop,
+  makePromise,
+  PROMISE_ID
+} from './-internal';
+
+import { asap } from './asap';
+
+export default function then(onFulfillment, onRejection) {
+  const parent = this;
+
+  const child = new this.constructor(noop);
+
+  if (child[PROMISE_ID] === undefined) {
+    makePromise(child);
+  }
+
+  const { _state } = parent;
+
+  if (_state) {
+    const callback = arguments[_state - 1];
+    asap(() => invokeCallback(_state, child, callback, parent._result));
+  } else {
+    subscribe(parent, child, onFulfillment, onRejection);
+  }
+
+  return child;
+}

data/node_modules/es6-promise/lib/es6-promise/utils.js

@@ -0,0 +1,21 @@
+export function objectOrFunction(x) {
+  let type = typeof x;
+  return x !== null && (type === 'object' || type === 'function');
+}
+
+export function isFunction(x) {
+  return typeof x === 'function';
+}
+
+export function isMaybeThenable(x) {
+  return x !== null && typeof x === 'object';
+}
+
+let _isArray;
+if (Array.isArray) {
+  _isArray = Array.isArray;
+} else {
+  _isArray = x => Object.prototype.toString.call(x) === '[object Array]';
+}
+
+export const isArray = _isArray;

data/node_modules/es6-promise/lib/es6-promise.auto.js

@@ -0,0 +1,3 @@
+import Promise from './es6-promise';
+Promise.polyfill();
+export default Promise;

data/node_modules/es6-promise/lib/es6-promise.js

@@ -0,0 +1,7 @@
+import Promise from './es6-promise/promise';
+import polyfill from './es6-promise/polyfill';
+
+// Strange compat..
+Promise.polyfill = polyfill;
+Promise.Promise = Promise;
+export default Promise;

data/node_modules/es6-promise/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "es6-promise",
+  "namespace": "es6-promise",
+  "version": "4.2.4",
+  "description": "A lightweight library that provides tools for organizing asynchronous code",
+  "main": "dist/es6-promise.js",
+  "typings": "es6-promise.d.ts",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "dist",
+    "lib",
+    "es6-promise.d.ts",
+    "auto.js",
+    "!dist/test"
+  ],
+  "devDependencies": {
+    "babel-plugin-transform-es2015-arrow-functions": "^6.22.0",
+    "babel-plugin-transform-es2015-block-scoping": "^6.24.1",
+    "babel-plugin-transform-es2015-classes": "^6.24.1",
+    "babel-plugin-transform-es2015-computed-properties": "^6.24.1",
+    "babel-plugin-transform-es2015-constants": "^6.1.4",
+    "babel-plugin-transform-es2015-destructuring": "^6.23.0",
+    "babel-plugin-transform-es2015-parameters": "^6.24.1",
+    "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
+    "babel-plugin-transform-es2015-spread": "^6.22.0",
+    "babel-plugin-transform-es2015-template-literals": "^6.22.0",
+    "babel6-plugin-strip-class-callcheck": "^6.0.0",
+    "broccoli-babel-transpiler": "^6.0.0",
+    "broccoli-concat": "^3.1.0",
+    "broccoli-merge-trees": "^2.0.0",
+    "broccoli-rollup": "^2.0.0",
+    "broccoli-stew": "^1.5.0",
+    "broccoli-uglify-js": "^0.2.0",
+    "broccoli-watchify": "^1.0.1",
+    "ember-cli": "2.18.0-beta.2",
+    "ember-cli-dependency-checker": "^2.1.0",
+    "git-repo-version": "1.0.1",
+    "json3": "^3.3.2",
+    "mocha": "^4.0.1",
+    "promises-aplus-tests-phantom": "^2.1.0-revise"
+  },
+  "scripts": {
+    "build": "ember build --environment production",
+    "start": "ember s",
+    "test": "ember test",
+    "test:server": "ember test --server",
+    "test:node": "ember test --launch Mocha",
+    "test:browser": "ember test --launch PhantomJS",
+    "prepublishOnly": "ember build --environment production"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stefanpenner/es6-promise.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stefanpenner/es6-promise/issues"
+  },
+  "browser": {
+    "vertx": false
+  },
+  "keywords": [
+    "promises",
+    "promise",
+    "polyfill",
+    "futures"
+  ],
+  "author": "Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)",
+  "license": "MIT",
+  "spm": {
+    "main": "dist/es6-promise.js"
+  },
+  "dependencies": {}
+}

data/node_modules/es6-promisify/README.md

@@ -0,0 +1,89 @@
+[![Travis CI](https://travis-ci.org/digitaldesignlabs/es6-promisify.svg)](https://travis-ci.org/digitaldesignlabs/es6-promisify)
+
+# es6-promisify
+
+Converts callback-based functions to Promise-based functions.
+
+## Install
+
+Install with [npm](https://npmjs.org/package/es6-promisify)
+
+```bash
+npm install --save es6-promisify
+```
+
+## Example
+
+```js
+"use strict";
+
+// Declare variables
+const promisify = require("es6-promisify");
+const fs = require("fs");
+
+// Convert the stat function
+const stat = promisify(fs.stat);
+
+// Now usable as a promise!
+stat("example.txt").then(function (stats) {
+    console.log("Got stats", stats);
+}).catch(function (err) {
+    console.error("Yikes!", err);
+});
+```
+
+## Promisify methods
+```js
+"use strict";
+
+// Declare variables
+const promisify = require("es6-promisify");
+const redis = require("redis").createClient(6379, "localhost");
+
+// Create a promise-based version of send_command
+const client = promisify(redis.send_command, redis);
+
+// Send commands to redis and get a promise back
+client("ping").then(function (pong) {
+    console.log("Got", pong);
+}).catch(function (err) {
+    console.error("Unexpected error", err);
+}).then(function () {
+    redis.quit();
+});
+```
+
+## Handle callback multiple arguments
+```js
+"use strict";
+
+// Declare functions
+function test(cb) {
+    return cb(undefined, 1, 2, 3);
+}
+
+// Declare variables
+const promisify = require("es6-promisify");
+
+// Create promise-based version of test
+const single = promisify(test);
+const multi = promisify(test, {multiArgs: true});
+
+// Discards additional arguments
+single().then(function (result) {
+    console.log(result); // 1
+});
+
+// Returns all arguments as an array
+multi().then(function (result) {
+    console.log(result); // [1, 2, 3]
+});
+```
+
+### Tests
+Test with nodeunit
+```bash
+$ npm test
+```
+
+Published under the [MIT License](http://opensource.org/licenses/MIT).