traceur-rb 0.0.1 → 0.0.2

data/vendor/node_modules/traceur/node_modules/rsvp/.release.json

@@ -0,0 +1,17 @@
+{
+  "non-interactive": true,
+  "dry-run": false,
+  "verbose": false,
+  "force": false,
+  "pkgFiles": ["package.json", "bower.json"],
+  "increment": "patch",
+  "commitMessage": "Release %s",
+  "tagName": "%s",
+  "tagAnnotation": "Release %s",
+  "buildCommand": "npm run-script build-all",
+  "distRepo": "git@github.com:components/rsvp.js.git",
+  "distStageDir": "tmp/stage",
+  "distBase": "dist",
+  "distFiles": ["**/*", "../package.json", "../bower.json"],
+  "publish": false
+}

data/vendor/node_modules/traceur/node_modules/rsvp/CHANGELOG.md

@@ -0,0 +1,165 @@
+# Master
+
+* improve performance of instrumentation (also add seperate flag to include "stack" with instrumentation as it is unfortunately slow)
+* ensure minified RSVP.defer() maintains known external API [#293](https://github.com/tildeio/rsvp.js/pull/293)
+* add `finally` to the readme
+* improve usage of browserify for promise/a+ tests
+* add wasteful files to gitignore
+* add [vert.x](http://vertx.io/) compatibility
+
+# 3.0.13
+
+* [Bugfix] fix `RSVP.hash` `RSVP.hashSettled` in runtimes < es5 by fixing a broken `Object.create` polyfil [#286](https://github.com/tildeio/rsvp.js/pull/286)
+* [Enhancement] cleanup & improve test related build tooling [#288](https://github.com/tildeio/rsvp.js/pull/288)
+
+# 3.0.12
+
+* [Bugfix] fix regression in denodeify that broke foreign thenables as arguments to denodeifed functions [#281](https://github.com/tildeio/rsvp.js/pull/281)
+
+# 3.0.11
+
+* [Bugfix] some onerror scenarios did not result in error notifications [4dcf](https://github.com/tildeio/rsvp.js/commit/4dcfa92bab6f5fc9e97ca3abfb71025a08984e7e)
+* [Bugfix] for more correctness internal optimization should only occure
+  if constructors equal, not just if instanceof check passes [96b5ec](https://github.com/tildeio/rsvp.js/commit/96b5ec201b2ddafc70cd5c836bc341a46081ae23)
+* fancy new s3 publishing thanks to @rondale-sc
+
+# 3.0.10
+
+* faster denodeify
+* rework tooling (Broccoli, testem, no grunt)
+* utilize bundle format for super small UMD builds
+
+# 3.0.9
+* [Bugfix] no longer include promise-aplus tests as a production
+  dependency
+* [Enhancement] fast then path for both rejection/fulfilment [0d252](https://github.com/tildeio/rsvp.js/commit/0d252ed4831eabb82991584e2e3eaae2a3a2ba42)
+* [Enhancement] short-cut for faster then chaining in specific scenarios
+  [#256](https://github.com/tildeio/rsvp.js/pull/256)
+
+# 3.0.8
+* [Bugfix] custom onerror handler, for potentially unhandled errors
+  would report unhandled errors in some incorrect scenarios.
+[#255](https://github.com/tildeio/rsvp.js/pull/255)
+
+# 3.0.7
+
+* improve tests in some older es5+ browsers
+* [Bugfix] denodeify should not use console for deprecation warning unless console is defined
+* [Enhancement] instrumentation should emit out-of-band. This should improve ember-extension performance
+* [Bugfix] race should not be susceptible to zalgo
+* [Perf] PromiseEnumerator increase performance of all enumerable methods all/allSettled/hash/hasSettled -> https://gist.github.com/stefanpenner/26465d5848f2924e2aca
+* [Docfix] Fix small documentation inconsistency
+* [Perf] an internal promise shouldn't bother validating `this` and `resolver`
+* [Perf] flatten asap’s QUEUE structure
+* [Perf] Reduce Constructor AST size.
+* [Perf] some versions of v8, think keep marking these functions to be optimized. This hints to them not to be.
+* [Perf] accidental resolve step, that merely needed to be a fulfill
+* [Perf/Enhancement] simplify publishing
+* [Spec ADdition]add spec test “Ensure `then` is always called with a clean stack.” ensure RSVP passes future a+ spec
+* [Bugfix] web worker support
+* [Docfix] Add a param name to make yuidoc happy
+* [Enhancement] simplify async vs sync pub/sub code-paths
+* [Bugfix] Passed the label through to the Promise object, as expected
+* [Docfix] missing Parentheses on promise example in documentation
+* [License] Add Stefan Penner to license
+* [Docfix] document `var promises` in filter.js
+
+# 3.0.3 -> 3.0.6 (missing changelog)
+
+* Changes to RSVP.denodeify: Behaviour for multiple success callback parameters
+  has been improved and the denodefied function now inherits from the original
+  node function.
+
+# 3.0.2
+
+* [Spec compliance] Promise.all and Promise.race should reject, not throw on invalid input
+* Add RSVP.allSettled
+
+# 3.0.1
+
+* Optimization: promises with noop resolvers now don't bother try to handle them.
+* [perf] skip costly resolver invocation if it is known not to be needed.
+* improve promise inspector interopt
+
+# 3.0.0
+
+* align with the promise spec
+  https://github.com/domenic/promises-unwrapping
+* idiomatic es6 usage
+* RSVP.all: now now casts rather then resolves, and doesn't touch the
+  "then"
+* RSVP.hash: now now casts rather then resolves, and doesn't touch the
+  "then"
+* MutationObserver: prefer text mutation, this fixes interop with
+  MutationObserver polyfils
+* Removing asap unload listener. Allows back/forward page cache, chrome
+  bug is old. Fixes #168
+* add grunt docs task
+* document: Promise.cast
+* document: Promise.resolve/Promise.reject
+* document: Promise.race
+* document: Promise.all
+* document: Promise.hash
+* document: RSVP.denodeify
+* document: RSVP.EventTarget
+* document: RSVP.rethrow
+* document: RSVP.defer
+* Document: RSVP.on('error'
+* Add Instrumentation hooks for tooling
+* Significant internal cleanup and performance improvements
+* require Promise constructor to be new'd (aligned with es6 spec)
+* Prefer tasks + config inline within project
+* Add Promise.finally
+* Add Promise.cast
+* Add Promise.resolve
+* Add Promise.reject
+* Add Promise.all
+* Add Promise.race
+* Add RSVP.map
+* Support promise inheritance
+* optimize onerror and reduce promise creation cost by 20x
+* promise/a+ 2.0.3 compliant
+* RSVP.async to schedule callbacks on internal queue
+* Optimization: only enforce a single nextTick for each queue flush.
+
+# 2.0.4
+
+* Fix npm package
+
+# 2.0.3
+
+* Fix useSetTimeout bug
+
+# 2.0.2
+
+* Adding RSVP#rethrow
+* add pre-built AMD link to README
+* adding promise#fail
+
+# 2.0.1
+* misc IE fixes, including IE array detection
+* upload passing builds to s3
+* async: use three args for addEventListener
+* satisfy both 1.0 and 1.1 specs
+* Run reduce tests only in node
+* RSVP.resolve now simply uses the internal resolution procedure
+* prevent multiple promise resolutions
+* simplify thenable handling
+* pre-allocate the deferred's shape
+* Moved from Rake-based builds to Grunt
+* Fix Promise subclassing bug
+* Add RSVP.configure('onerror')
+* Throw exception when RSVP.all is called without an array
+* refactor RSVP.all to just use a promise directly
+* Make `RSVP.denodeify` pass along `thisArg`
+* add RSVP.reject
+* Reject promise if resolver function throws an exception
+* add travis build-status
+* correctly test and fix self fulfillment
+* remove promise coercion.
+* Fix infinite recursion with deep self fulfilling promises
+* doc fixes
+
+# 2.0.0
+
+* No changelog beyond this point. Here be dragons.

data/vendor/node_modules/traceur/node_modules/rsvp/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors
+
+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/vendor/node_modules/traceur/node_modules/rsvp/README.md

@@ -0,0 +1,364 @@
+# RSVP.js  [![Build Status](https://secure.travis-ci.org/tildeio/rsvp.js.png?branch=master)](http://travis-ci.org/tildeio/rsvp.js)
+
+RSVP.js provides simple tools for organizing asynchronous code.
+
+Specifically, it is a tiny implementation of Promises/A+.
+
+It works in node and the browser (IE6+, all the popular evergreen ones).
+
+## downloads
+
+- [rsvp-latest](http://rsvpjs-builds.s3.amazonaws.com/rsvp-latest.js)
+- [rsvp-latest (minified)](http://rsvpjs-builds.s3.amazonaws.com/rsvp-latest.min.js)
+
+## Promises
+
+
+Although RSVP is es6 compliant, it does bring along some extra toys. If you would prefer a strict es6 subset, I would suggest checking out our sibling project https://github.com/jakearchibald/es6-promise, It is RSVP but stripped down to the es6 spec features.
+
+## Bower
+
+`bower install -S rsvp`
+
+## NPM
+
+`npm install --save rsvp`
+
+`RSVP.Promise` is an implementation of
+[Promises/A+](http://promises-aplus.github.com/promises-spec/) that passes the
+[test suite](https://github.com/promises-aplus/promises-tests).
+
+It delivers all promises asynchronously, even if the value is already
+available, to help you write consistent code that doesn't change if the
+underlying data provider changes from synchronous to asynchronous.
+
+It is compatible with [TaskJS](http://taskjs.org/), a library by Dave
+Herman of Mozilla that uses ES6 generators to allow you to write
+synchronous code with promises. It currently works in Firefox, and will
+work in any browser that adds support for ES6 generators. See the
+section below on TaskJS for more information.
+
+### Basic Usage
+
+```javascript
+var RSVP = require('rsvp');
+
+var promise = new RSVP.Promise(function(resolve, reject) {
+  // succeed
+  resolve(value);
+  // or reject
+  reject(error);
+});
+
+promise.then(function(value) {
+  // success
+}, function(value) {
+  // failure
+});
+```
+
+Once a promise has been resolved or rejected, it cannot be resolved or
+rejected again.
+
+Here is an example of a simple XHR2 wrapper written using RSVP.js:
+
+```javascript
+var getJSON = function(url) {
+  var promise = new RSVP.Promise(function(resolve, reject){
+    var client = new XMLHttpRequest();
+    client.open("GET", url);
+    client.onreadystatechange = handler;
+    client.responseType = "json";
+    client.setRequestHeader("Accept", "application/json");
+    client.send();
+
+    function handler() {
+      if (this.readyState === this.DONE) {
+        if (this.status === 200) { resolve(this.response); }
+        else { reject(this); }
+      }
+    };
+  });
+
+  return promise;
+};
+
+getJSON("/posts.json").then(function(json) {
+  // continue
+}, function(error) {
+  // handle errors
+});
+```
+
+### Chaining
+
+One of the really awesome features of Promises/A+ promises are that they
+can be chained together. In other words, the return value of the first
+resolve handler will be passed to the second resolve handler.
+
+If you return a regular value, it will be passed, as is, to the next
+handler.
+
+```javascript
+getJSON("/posts.json").then(function(json) {
+  return json.post;
+}).then(function(post) {
+  // proceed
+});
+```
+
+The really awesome part comes when you return a promise from the first
+handler:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  // save off post
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to post and comments
+});
+```
+
+This allows you to flatten out nested callbacks, and is the main feature
+of promises that prevents "rightward drift" in programs with a lot of
+asynchronous code.
+
+Errors also propagate:
+
+```javascript
+getJSON("/posts.json").then(function(posts) {
+
+}).catch(function(error) {
+  // since no rejection handler was passed to the
+  // first `.then`, the error propagates.
+});
+```
+
+You can use this to emulate `try/catch` logic in synchronous code.
+Simply chain as many resolve callbacks as a you want, and add a failure
+handler at the end to catch errors.
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to posts and comments
+}).catch(function(error) {
+  // handle errors in either of the two requests
+});
+```
+
+You can also use `catch` for error handling, which is a shortcut for
+`then(null, rejection)`, like so:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).catch(function(error) {
+  // handle errors
+});
+```
+
+## Error Handling
+
+There are times when dealing with promises that it seems like any errors
+are being 'swallowed', and not properly raised. This makes is extremely
+difficult to track down where a given issue is coming from. Thankfully,
+`RSVP` has a solution for this problem built in.
+
+You can register functions to be called when an uncaught error occurs
+within your promises. These callback functions can be anything, but a common
+practice is to call `console.assert` to dump the error to the console.
+
+```javascript
+RSVP.on('error', function(reason) {
+  console.assert(false, reason);
+});
+```
+
+**NOTE:** promises do allow for errors to be handled asynchronously, so
+this callback may result in false positives.
+
+**NOTE:** Usage of `RSVP.configure('onerror', yourCustomFunction);` is
+deprecated in favor of using `RSVP.on`.
+
+
+## Finally
+
+`finally` will be invoked regardless of the promise's fate, just as native
+try/catch/finally behaves.
+
+```js
+findAuthor().catch(function(reason){
+  return findOtherAuthor();
+}).finally(function(){
+  // author was either found, or not
+});
+```
+
+
+## Arrays of promises
+
+Sometimes you might want to work with many promises at once. If you
+pass an array of promises to the `all()` method it will return a new
+promise that will be fulfilled when all of the promises in the array
+have been fulfilled; or rejected immediately if any promise in the array
+is rejected.
+
+```javascript
+var promises = [2, 3, 5, 7, 11, 13].map(function(id){
+  return getJSON("/post/" + id + ".json");
+});
+
+RSVP.all(promises).then(function(posts) {
+  // posts contains an array of results for the given promises
+}).catch(function(reason){
+  // if any of the promises fails.
+});
+```
+
+## Hash of promises
+
+If you need to reference many promises at once (like `all()`), but would like
+to avoid encoding the actual promise order you can use `hash()`. If you pass
+an object literal (where the values are promises) to the `hash()` method it will
+return a new promise that will be fulfilled when all of the promises have been
+fulfilled; or rejected immediately if any promise is rejected.
+
+The key difference to the `all()` function is that both the fulfillment value
+and the argument to the `hash()` function are object literals. This allows
+you to simply reference the results directly off the returned object without
+having to remember the initial order like you would with `all()`.
+
+```javascript
+var promises = {
+  posts: getJSON("/posts.json"),
+  users: getJSON("/users.json")
+};
+
+RSVP.hash(promises).then(function(results) {
+  console.log(results.users) // print the users.json results
+  console.log(results.posts) // print the posts.json results
+});
+```
+
+## All settled and hash settled
+
+Sometimes you want to work with several promises at once, but instead of
+rejecting immediately if any promise is rejected, as with `all()` or `hash()`,
+you want to be able to inspect the results of all your promises, whether
+they fulfill or reject. For this purpose, you can use `allSettled()` and
+`hashSettled()`. These work exactly like `all()` and `hash()`, except that
+they fulfill with an array or hash (respectively) of the constituent promises'
+result states. Each state object will either indicate fulfillment or
+rejection, and provide the corresponding value or reason. The states will take
+one of the following formats:
+
+```javascript
+{ state: 'fulfilled', value: value }
+  or
+{ state: 'rejected', reason: reason }
+```
+
+## Deferred
+
+> The `RSVP.Promise` constructor is generally a better, less error-prone choice
+> than `RSVP.defer()`. Promises are recommended unless the specific 
+> properties of deferred are needed.
+
+Sometimes one need to create a deferred object, without immediately specifying
+how it will be resolved. These deferred objects are essentially a wrapper around
+a promise, whilst providing late access to the `resolve()` and `reject()` methods.
+
+A deferred object has this form: `{ promise, resolve(x), reject(r) }`.
+
+```javascript
+var deferred = RSVP.defer();
+// ...
+deferred.promise // access the promise
+// ...
+deferred.resolve();
+
+```
+
+## TaskJS
+
+The [TaskJS](http://taskjs.org/) library makes it possible to take
+promises-oriented code and make it synchronous using ES6 generators.
+
+Let's review an earlier example:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to posts and comments
+}).catch(function(reason) {
+  // handle errors in either of the two requests
+});
+```
+
+Without any changes to the implementation of `getJSON`, you could write
+the following code with TaskJS:
+
+```javascript
+spawn(function *() {
+  try {
+    var post = yield getJSON("/post/1.json");
+    var comments = yield getJSON(post.commentURL);
+  } catch(error) {
+    // handle errors
+  }
+});
+```
+
+In the above example, `function *` is new syntax in ES6 for
+[generators](http://wiki.ecmascript.org/doku.php?id=harmony:generators).
+Inside a generator, `yield` pauses the generator, returning control to
+the function that invoked the generator. In this case, the invoker is a
+special function that understands the semantics of Promises/A, and will
+automatically resume the generator as soon as the promise is resolved.
+
+The cool thing here is the same promises that work with current
+JavaScript using `.then` will work seamlessly with TaskJS once a browser
+has implemented it!
+
+## Instrumentation
+
+```js
+function listener (event) {
+  event.guid      // guid of promise. Must be globally unique, not just within the implementation
+  event.childGuid // child of child promise (for chained via `then`)
+  event.eventName // one of ['created', 'chained', 'fulfilled', 'rejected']
+  event.detail    // fulfillment value or rejection reason, if applicable
+  event.label     // label passed to promise's constructor
+  event.timeStamp // milliseconds elapsed since 1 January 1970 00:00:00 UTC up until now
+  event.stack     // stack at the time of the event. (if  'instrument-with-stack' is true)
+}
+
+RSVP.configure('instrument', true | false);
+// capturing the stacks is slow, so you also have to opt in
+RSVP.configure('instrument-with-stack', true | false);
+
+// events
+RSVP.on('created', listener);
+RSVP.on('chained', listener);
+RSVP.on('fulfilled', listener);
+RSVP.on('rejected', listener);
+```
+        
+Events are only triggered when `RSVP.configure('instrument')` is true, although
+listeners can be registered at any time.
+
+## Building & Testing
+
+Custom tasks:
+
+* `ember build` - Build distribution
+* `testem ci` - Run tests.
+* `testem` - Run test server.
+
+## Releasing
+
+Check what release-it will do by running `npm run-script dry-run-release`.
+To actually release, run `node_modules/.bin/release-it`.