traceur-rb 0.0.1 → 0.0.2

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/all.js

@@ -0,0 +1,15 @@
+import Promise from "./promise";
+
+/**
+  This is a convenient alias for `RSVP.Promise.all`.
+
+  @method all
+  @static
+  @for RSVP
+  @param {Array} array Array of promises.
+  @param {String} label An optional label. This is useful
+  for tooling.
+*/
+export default function all(array, label) {
+  return Promise.all(array, label);
+}

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/asap.js

@@ -0,0 +1,109 @@
+var len = 0;
+
+export default function asap(callback, arg) {
+  queue[len] = callback;
+  queue[len + 1] = arg;
+  len += 2;
+  if (len === 2) {
+    // If len is 1, that means that we need to schedule an async flush.
+    // If additional callbacks are queued before the queue is flushed, they
+    // will be processed by this flush that we are scheduling.
+    scheduleFlush();
+  }
+}
+
+var browserWindow = (typeof window !== 'undefined') ? window : undefined
+var browserGlobal = browserWindow || {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var isNode = typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+
+// test for web worker but not in IE10
+var isWorker = typeof Uint8ClampedArray !== 'undefined' &&
+  typeof importScripts !== 'undefined' &&
+  typeof MessageChannel !== 'undefined';
+
+// node
+function useNextTick() {
+  var nextTick = process.nextTick;
+  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+  // setImmediate should be used instead instead
+  var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
+  if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
+    nextTick = setImmediate;
+  }
+  return function() {
+    nextTick(flush);
+  };
+}
+
+// vertx
+function useVertxTimer() {
+  return function() {
+    vertxNext(flush);
+  };
+}
+
+function useMutationObserver() {
+  var iterations = 0;
+  var observer = new BrowserMutationObserver(flush);
+  var node = document.createTextNode('');
+  observer.observe(node, { characterData: true });
+
+  return function() {
+    node.data = (iterations = ++iterations % 2);
+  };
+}
+
+// web worker
+function useMessageChannel() {
+  var channel = new MessageChannel();
+  channel.port1.onmessage = flush;
+  return function () {
+    channel.port2.postMessage(0);
+  };
+}
+
+function useSetTimeout() {
+  return function() {
+    setTimeout(flush, 1);
+  };
+}
+
+var queue = new Array(1000);
+function flush() {
+  for (var i = 0; i < len; i+=2) {
+    var callback = queue[i];
+    var arg = queue[i+1];
+
+    callback(arg);
+
+    queue[i] = undefined;
+    queue[i+1] = undefined;
+  }
+
+  len = 0;
+}
+
+function attemptVertex() {
+  try {
+    var vertx = require('vertx');
+    var vertxNext = vertx.runOnLoop || vertx.runOnContext;
+    return useVertxTimer();
+  } catch(e) {
+    return useSetTimeout();
+  }
+}
+
+var scheduleFlush;
+// Decide what async method to use to triggering processing of queued callbacks:
+if (isNode) {
+  scheduleFlush = useNextTick();
+} else if (BrowserMutationObserver) {
+  scheduleFlush = useMutationObserver();
+} else if (isWorker) {
+  scheduleFlush = useMessageChannel();
+} else if (browserWindow === undefined && typeof require === 'function') {
+  scheduleFlush = attemptVertex();
+} else {
+  scheduleFlush = useSetTimeout();
+}

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/config.js

@@ -0,0 +1,28 @@
+import EventTarget from './events';
+
+var config = {
+  instrument: false
+};
+
+EventTarget['mixin'](config);
+
+function configure(name, value) {
+  if (name === 'onerror') {
+    // handle for legacy users that expect the actual
+    // error to be passed to their function added via
+    // `RSVP.configure('onerror', someFunctionHere);`
+    config['on']('error', value);
+    return;
+  }
+
+  if (arguments.length === 2) {
+    config[name] = value;
+  } else {
+    return config[name];
+  }
+}
+
+export {
+  config,
+  configure
+};

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/defer.js

@@ -0,0 +1,45 @@
+import Promise from "./promise";
+
+/**
+  `RSVP.defer` returns an object similar to jQuery's `$.Deferred`.
+  `RSVP.defer` should be used when porting over code reliant on `$.Deferred`'s
+  interface. New code should use the `RSVP.Promise` constructor instead.
+
+  The object returned from `RSVP.defer` is a plain object with three properties:
+
+  * promise - an `RSVP.Promise`.
+  * reject - a function that causes the `promise` property on this object to
+    become rejected
+  * resolve - a function that causes the `promise` property on this object to
+    become fulfilled.
+
+  Example:
+
+   ```javascript
+   var deferred = RSVP.defer();
+
+   deferred.resolve("Success!");
+
+   deferred.promise.then(function(value){
+     // value here is "Success!"
+   });
+   ```
+
+  @method defer
+  @static
+  @for RSVP
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @return {Object}
+ */
+
+export default function defer(label) {
+  var deferred = { };
+
+  deferred['promise'] = new Promise(function(resolve, reject) {
+    deferred['resolve'] = resolve;
+    deferred['reject'] = reject;
+  }, label);
+
+  return deferred;
+}

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/enumerator.js

@@ -0,0 +1,125 @@
+import {
+  isArray,
+  isMaybeThenable
+} from './utils';
+
+import {
+  noop,
+  reject,
+  fulfill,
+  subscribe,
+  FULFILLED,
+  REJECTED,
+  PENDING
+} from './-internal';
+
+export function makeSettledResult(state, position, value) {
+  if (state === FULFILLED) {
+    return {
+      state: 'fulfilled',
+      value: value
+    };
+  } else {
+    return {
+      state: 'rejected',
+      reason: value
+    };
+  }
+}
+
+function Enumerator(Constructor, input, abortOnReject, label) {
+  this._instanceConstructor = Constructor;
+  this.promise = new Constructor(noop, label);
+  this._abortOnReject = abortOnReject;
+
+  if (this._validateInput(input)) {
+    this._input     = input;
+    this.length     = input.length;
+    this._remaining = input.length;
+
+    this._init();
+
+    if (this.length === 0) {
+      fulfill(this.promise, this._result);
+    } else {
+      this.length = this.length || 0;
+      this._enumerate();
+      if (this._remaining === 0) {
+        fulfill(this.promise, this._result);
+      }
+    }
+  } else {
+    reject(this.promise, this._validationError());
+  }
+}
+
+export default Enumerator;
+
+Enumerator.prototype._validateInput = function(input) {
+  return isArray(input);
+};
+
+Enumerator.prototype._validationError = function() {
+  return new Error('Array Methods must be provided an Array');
+};
+
+Enumerator.prototype._init = function() {
+  this._result = new Array(this.length);
+};
+
+Enumerator.prototype._enumerate = function() {
+  var length  = this.length;
+  var promise = this.promise;
+  var input   = this._input;
+
+  for (var i = 0; promise._state === PENDING && i < length; i++) {
+    this._eachEntry(input[i], i);
+  }
+};
+
+Enumerator.prototype._eachEntry = function(entry, i) {
+  var c = this._instanceConstructor;
+  if (isMaybeThenable(entry)) {
+    if (entry.constructor === c && entry._state !== PENDING) {
+      entry._onError = null;
+      this._settledAt(entry._state, i, entry._result);
+    } else {
+      this._willSettleAt(c.resolve(entry), i);
+    }
+  } else {
+    this._remaining--;
+    this._result[i] = this._makeResult(FULFILLED, i, entry);
+  }
+};
+
+Enumerator.prototype._settledAt = function(state, i, value) {
+  var promise = this.promise;
+
+  if (promise._state === PENDING) {
+    this._remaining--;
+
+    if (this._abortOnReject && state === REJECTED) {
+      reject(promise, value);
+    } else {
+      this._result[i] = this._makeResult(state, i, value);
+    }
+  }
+
+  if (this._remaining === 0) {
+    fulfill(promise, this._result);
+  }
+};
+
+Enumerator.prototype._makeResult = function(state, i, value) {
+  return value;
+};
+
+Enumerator.prototype._willSettleAt = function(promise, i) {
+  var enumerator = this;
+
+  subscribe(promise, undefined, function(value) {
+    enumerator._settledAt(FULFILLED, i, value);
+  }, function(reason) {
+    enumerator._settledAt(REJECTED, i, reason);
+  });
+};

data/vendor/node_modules/traceur/node_modules/rsvp/lib/rsvp/events.js

@@ -0,0 +1,201 @@
+function indexOf(callbacks, callback) {
+  for (var i=0, l=callbacks.length; i<l; i++) {
+    if (callbacks[i] === callback) { return i; }
+  }
+
+  return -1;
+}
+
+function callbacksFor(object) {
+  var callbacks = object._promiseCallbacks;
+
+  if (!callbacks) {
+    callbacks = object._promiseCallbacks = {};
+  }
+
+  return callbacks;
+}
+
+/**
+  @class RSVP.EventTarget
+*/
+export default {
+
+  /**
+    `RSVP.EventTarget.mixin` extends an object with EventTarget methods. For
+    Example:
+
+    ```javascript
+    var object = {};
+
+    RSVP.EventTarget.mixin(object);
+
+    object.on('finished', function(event) {
+      // handle event
+    });
+
+    object.trigger('finished', { detail: value });
+    ```
+
+    `EventTarget.mixin` also works with prototypes:
+
+    ```javascript
+    var Person = function() {};
+    RSVP.EventTarget.mixin(Person.prototype);
+
+    var yehuda = new Person();
+    var tom = new Person();
+
+    yehuda.on('poke', function(event) {
+      console.log('Yehuda says OW');
+    });
+
+    tom.on('poke', function(event) {
+      console.log('Tom says OW');
+    });
+
+    yehuda.trigger('poke');
+    tom.trigger('poke');
+    ```
+
+    @method mixin
+    @for RSVP.EventTarget
+    @private
+    @param {Object} object object to extend with EventTarget methods
+  */
+  'mixin': function(object) {
+    object['on']      = this['on'];
+    object['off']     = this['off'];
+    object['trigger'] = this['trigger'];
+    object._promiseCallbacks = undefined;
+    return object;
+  },
+
+  /**
+    Registers a callback to be executed when `eventName` is triggered
+
+    ```javascript
+    object.on('event', function(eventInfo){
+      // handle the event
+    });
+
+    object.trigger('event');
+    ```
+
+    @method on
+    @for RSVP.EventTarget
+    @private
+    @param {String} eventName name of the event to listen for
+    @param {Function} callback function to be called when the event is triggered.
+  */
+  'on': function(eventName, callback) {
+    var allCallbacks = callbacksFor(this), callbacks;
+
+    callbacks = allCallbacks[eventName];
+
+    if (!callbacks) {
+      callbacks = allCallbacks[eventName] = [];
+    }
+
+    if (indexOf(callbacks, callback) === -1) {
+      callbacks.push(callback);
+    }
+  },
+
+  /**
+    You can use `off` to stop firing a particular callback for an event:
+
+    ```javascript
+    function doStuff() { // do stuff! }
+    object.on('stuff', doStuff);
+
+    object.trigger('stuff'); // doStuff will be called
+
+    // Unregister ONLY the doStuff callback
+    object.off('stuff', doStuff);
+    object.trigger('stuff'); // doStuff will NOT be called
+    ```
+
+    If you don't pass a `callback` argument to `off`, ALL callbacks for the
+    event will not be executed when the event fires. For example:
+
+    ```javascript
+    var callback1 = function(){};
+    var callback2 = function(){};
+
+    object.on('stuff', callback1);
+    object.on('stuff', callback2);
+
+    object.trigger('stuff'); // callback1 and callback2 will be executed.
+
+    object.off('stuff');
+    object.trigger('stuff'); // callback1 and callback2 will not be executed!
+    ```
+
+    @method off
+    @for RSVP.EventTarget
+    @private
+    @param {String} eventName event to stop listening to
+    @param {Function} callback optional argument. If given, only the function
+    given will be removed from the event's callback queue. If no `callback`
+    argument is given, all callbacks will be removed from the event's callback
+    queue.
+  */
+  'off': function(eventName, callback) {
+    var allCallbacks = callbacksFor(this), callbacks, index;
+
+    if (!callback) {
+      allCallbacks[eventName] = [];
+      return;
+    }
+
+    callbacks = allCallbacks[eventName];
+
+    index = indexOf(callbacks, callback);
+
+    if (index !== -1) { callbacks.splice(index, 1); }
+  },
+
+  /**
+    Use `trigger` to fire custom events. For example:
+
+    ```javascript
+    object.on('foo', function(){
+      console.log('foo event happened!');
+    });
+    object.trigger('foo');
+    // 'foo event happened!' logged to the console
+    ```
+
+    You can also pass a value as a second argument to `trigger` that will be
+    passed as an argument to all event listeners for the event:
+
+    ```javascript
+    object.on('foo', function(value){
+      console.log(value.name);
+    });
+
+    object.trigger('foo', { name: 'bar' });
+    // 'bar' logged to the console
+    ```
+
+    @method trigger
+    @for RSVP.EventTarget
+    @private
+    @param {String} eventName name of the event to be triggered
+    @param {Any} options optional value to be passed to any event handlers for
+    the given `eventName`
+  */
+  'trigger': function(eventName, options) {
+    var allCallbacks = callbacksFor(this), callbacks, callback;
+
+    if (callbacks = allCallbacks[eventName]) {
+      // Don't cache the callbacks.length since it may grow
+      for (var i=0; i<callbacks.length; i++) {
+        callback = callbacks[i];
+
+        callback(options);
+      }
+    }
+  }
+};