closure 1.1.692

data/closure-library/third_party/closure/goog/mochikit/async/deferredlist.js

@@ -0,0 +1,199 @@
+// Copyright 2005 Bob Ippolito. All Rights Reserved.
+// Modifications Copyright 2009 The Closure Library Authors.
+// All Rights Reserved.
+
+/**
+ * @license Portions of this code are from MochiKit, received by The Closure
+ * Library Authors under the MIT license. All other code is Copyright
+ * 2005-2009 The Closure Library Authors. All Rights Reserved.
+ */
+
+/**
+ * @fileoverview Class for tracking multiple asynchronous operations and
+ * handling the results. The DeferredList object here is patterned after the
+ * DeferredList object in the Twisted python networking framework.
+ *
+ * Based on the MochiKit code.
+ *
+ * See: http://twistedmatrix.com/projects/core/documentation/howto/defer.html
+ *
+ */
+
+goog.provide('goog.async.DeferredList');
+
+goog.require('goog.array');
+goog.require('goog.async.Deferred');
+
+
+
+/**
+ * Constructs an object that waits on the results of multiple asynchronous
+ * operations and marshals the results. It is itself a <code>Deferred</code>,
+ * and sends results to its registered callback chain. Each instance is single
+ * use and may only fire once.
+ *
+ * Unless overridden by one of the options below, the <code>DeferredList</code>
+ * will wait for a result from every input <code>Deferred</code>. The results
+ * are stored in a list of two-element arrays as <code>[success, result]</code>,
+ * where <code>success</code> is whether that result was from a callback or
+ * errback. Once all results are available, the <code>DeferredList</code>'s
+ * callback chain is invoked with the full result list.
+ *
+ * @param {!Array.<!goog.async.Deferred>} list An array of deferred objects to
+ *     wait for.
+ * @param {boolean=} opt_fireOnOneCallback Whether to stop waiting as soon as
+ *     one input completes successfully. In this case, the
+ *     <code>DeferredList</code>'s callback chain will be called with a two
+ *     element array, <code>[index, result]</code>, where <code>index</code>
+ *     identifies which input <code>Deferred</code> produced the
+ *     <code>result</code>.
+ * @param {boolean=} opt_fireOnOneErrback Whether to stop waiting as soon as one
+ *     input reports an error. The error result is passed to the
+ *     <code>DeferredList</code>'s error callback chain.
+ * @param {boolean=} opt_consumeErrors When true, will stop propagation of the
+ *     error callback chain for input deferred objects. If the failing deferred
+ *     has a registered callback after this <code>DeferredList</code>, it will
+ *     be called with null instead of an <code>Error</code>.
+ * @param {Function=} opt_canceller A function that will be called if the
+ *     deferred list is canceled.
+ * @param {Object=} opt_defaultScope The default scope to call callbacks with.
+ * @constructor
+ * @extends {goog.async.Deferred}
+ */
+goog.async.DeferredList = function(list,
+                                   opt_fireOnOneCallback,
+                                   opt_fireOnOneErrback,
+                                   opt_consumeErrors,
+                                   opt_canceller,
+                                   opt_defaultScope) {
+  goog.async.Deferred.call(this, opt_canceller, opt_defaultScope);
+
+  /**
+   * The list of Deferred objects to wait for.
+   * @type {!Array.<!goog.async.Deferred>}
+   * @private
+   */
+  this.list_ = list;
+
+  /**
+   * The stored return values of the Deferred objects.
+   * @type {!Array}
+   * @private
+   */
+  this.deferredResults_ = [];
+
+  /**
+   * Whether to fire on the first successful callback instead of waiting for
+   * every Deferred to complete.
+   * @type {boolean}
+   * @private
+   */
+  this.fireOnOneCallback_ = !!opt_fireOnOneCallback;
+
+  /**
+   * Whether to fire on the first error result received instead of waiting for
+   * every Deferred to complete.
+   * @type {boolean}
+   * @private
+   */
+  this.fireOnOneErrback_ = !!opt_fireOnOneErrback;
+
+  /**
+   * Whether to stop error propagation on the input Deferred objects. If the
+   * DeferredList sees an error from one of the Deferred inputs, the error will
+   * be captured, and the Deferred will be returned to success state with a null
+   * return value.
+   * @type {boolean}
+   * @private
+   */
+  this.consumeErrors_ = !!opt_consumeErrors;
+
+  for (var i = 0; i < list.length; i++) {
+    var d = list[i];
+    d.addCallbacks(goog.bind(this.handleCallback_, this, i, true),
+                   goog.bind(this.handleCallback_, this, i, false));
+  }
+
+  if (list.length == 0 && !this.fireOnOneCallback_) {
+    this.callback(this.deferredResults_);
+  }
+};
+goog.inherits(goog.async.DeferredList, goog.async.Deferred);
+
+
+/**
+ * The number of input deferred objects that have fired.
+ * @type {number}
+ * @private
+ */
+goog.async.DeferredList.prototype.numFinished_ = 0;
+
+
+/**
+ * Registers the result from an input deferred callback or errback. The result
+ * is returned and may be passed to additional handlers in the callback chain.
+ *
+ * @param {number} index The index of the firing deferred object in the input
+ *     list.
+ * @param {boolean} success Whether the result is from a callback or errback.
+ * @param {*} result The result of the callback or errback.
+ * @return {*} The result, to be handled by the next handler in the deferred's
+ *     callback chain (if any). If consumeErrors is set, an error result is
+ *     replaced with null.
+ * @private
+ */
+goog.async.DeferredList.prototype.handleCallback_ = function(index,
+                                                             success,
+                                                             result) {
+  this.numFinished_++;
+  this.deferredResults_[index] = [success, result];
+
+  if (!this.hasFired()) {
+    if (this.fireOnOneCallback_ && success) {
+      this.callback([index, result]);
+    } else if (this.fireOnOneErrback_ && !success) {
+      this.errback(result);
+    } else if (this.numFinished_ == this.list_.length) {
+      this.callback(this.deferredResults_);
+    }
+  }
+
+  if (this.consumeErrors_ && !success) {
+    result = null;
+  }
+
+  return result;
+};
+
+
+/** @inheritDoc */
+goog.async.DeferredList.prototype.errback = function(res) {
+  goog.async.DeferredList.superClass_.errback.call(this, res);
+  // On error, cancel any pending requests.
+  goog.array.forEach(this.list_, function(item) {
+    item.cancel();
+  });
+};
+
+
+/**
+ * Creates a <code>DeferredList</code> that gathers results from multiple
+ * <code>Deferred</code> inputs. If all inputs succeed, the callback is fired
+ * with the list of results as a flat array. If any input fails, the errback is
+ * fired with the error.
+ *
+ * @param {!Array.<!goog.async.Deferred>} list The list of deferred objects to
+ *     wait for.
+ * @return {!goog.async.DeferredList} A new deferred list.
+ */
+goog.async.DeferredList.gatherResults = function(list) {
+  var d = new goog.async.DeferredList(list, false, true);
+
+  d.addCallback(function(results) {
+    return goog.array.map(results, function(res) {
+      return res[1];
+    });
+  });
+
+  return d;
+};

data/closure-library/third_party/closure/goog/mochikit/async/deferredlist_test.html

@@ -0,0 +1,426 @@
+<!DOCTYPE html>
+<html>
+<!--
+  Copyright 2009 The Closure Library Authors. All Rights Reserved.
+-->
+<head>
+<title>Closure Unit Tests - goog.async.DeferredList</title>
+<script src="../../../../../closure/goog/base.js"></script>
+<script src="../../deps.js"></script>
+<script>
+
+goog.require('goog.array');
+goog.require('goog.async.Deferred');
+goog.require('goog.async.DeferredList');
+goog.require('goog.testing.jsunit');
+
+</script>
+</head>
+<body>
+<script>
+
+var Deferred = goog.async.Deferred;
+var DeferredList = goog.async.DeferredList;
+
+
+/**
+ * A list of unhandled errors.
+ * @type {Array.<Error>}
+ */
+var storedErrors = [];
+
+
+/**
+ * Adds a catch-all error handler to deferred objects. Unhandled errors that
+ * reach the catch-all will be rethrown during tearDown.
+ *
+ * @param {...Deferred} var_args A list of deferred objects.
+ */
+function addCatchAll(var_args) {
+  for (var i = 0, d; d = arguments[i]; i++) {
+    d.addErrback(function(res) {
+      storedErrors.push(res);
+    });
+  }
+}
+
+
+/**
+ * Checks storedErrors for unhandled errors. If found, the error is rethrown.
+ */
+function checkCatchAll() {
+  var err = storedErrors.shift();
+  goog.array.clear(storedErrors);
+
+  if (err) {
+    throw err;
+  }
+}
+
+
+function tearDown() {
+  checkCatchAll();
+}
+
+
+function neverHappen(res) {
+  fail('This should not happen');
+}
+
+
+function testNoInputs() {
+  var count = 0;
+  var d = new DeferredList([]);
+
+  d.addCallback(function(res) {
+    assertArrayEquals([], res);
+    count++;
+  });
+  addCatchAll(d);
+
+  assertEquals('An empty DeferredList should fire immediately with an empty ' +
+               'list of results.',
+               1, count);
+}
+
+
+function testNoInputsAndFireOnOneCallback() {
+  var count = 0;
+  var d = new DeferredList([], true);
+
+  d.addCallback(function(res) {
+    assertArrayEquals([], res);
+    count++;
+  });
+  addCatchAll(d);
+
+  assertEquals('An empty DeferredList with opt_fireOnOneCallback set should ' +
+               'not fire unless callback is invoked explicitly.',
+               0, count);
+
+  d.callback([]);
+  assertEquals('Calling callback explicitly should still fire.', 1, count);
+}
+
+
+function testDeferredList() {
+  var count = 0;
+  var results;
+
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+
+  var dl = new DeferredList([a, b, c]);
+
+  dl.addCallback(function(res) {
+    assertEquals('Expected 3 Deferred results.', 3, res.length);
+
+    assertTrue('Deferred a should return success.', res[0][0]);
+    assertFalse('Deferred b should return failure.', res[1][0]);
+    assertTrue('Deferred c should return success.', res[2][0]);
+
+    assertEquals('Unexpected return value for a.', 'A', res[0][1]);
+    assertEquals('Unexpected return value for c.', 'C', res[2][1]);
+
+    assertEquals('B', res[1][1]);
+
+    count++;
+  });
+
+  addCatchAll(dl);
+
+  c.callback('C');
+  assertEquals(0, count);
+
+  b.errback('B');
+  assertEquals(0, count);
+
+  a.callback('A');
+
+  checkCatchAll();
+  assertEquals('DeferredList should fire on last call or errback.', 1, count);
+}
+
+
+function testFireOnFirstCallback() {
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+
+  var dl = new DeferredList([a, b, c], true);
+
+  dl.addCallback(function(res) {
+    assertEquals('Should be the deferred index in this mode.', 1, res[0]);
+    assertEquals('B', res[1]);
+  });
+  dl.addErrback(neverHappen);
+
+  addCatchAll(dl);
+
+  a.errback('A');
+  b.callback('B');
+
+  // Shouldn't cause any more callbacks on the DeferredList.
+  c.callback('C');
+}
+
+
+function testFireOnFirstErrback() {
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+
+  var dl = new DeferredList([a, b, c], false, true);
+
+  dl.addCallback(neverHappen);
+  dl.addErrback(function(res) {
+    assertEquals('A', res);
+
+    // Return a non-error value to break out of the errback path.
+    return true;
+  });
+
+  addCatchAll(dl);
+
+  b.callback('B');
+  a.errback('A');
+
+  // Shouldn't cause any more callbacks on the DeferredList.
+  c.callback('C');
+}
+
+
+function testNoConsumeErrors() {
+  var count = 0;
+
+  var a = new Deferred();
+  var dl = new DeferredList([a]);
+
+  a.addErrback(function(res) {
+    count++;
+    return true;
+  });
+
+  addCatchAll(a, dl);
+
+  a.errback('oh noes');
+  assertEquals(1, count);
+}
+
+
+function testConsumeErrors() {
+  var count = 0;
+
+  var a = new Deferred();
+  var dl = new DeferredList([a], false, false, true);
+
+  a.addErrback(neverHappen);
+
+  addCatchAll(a, dl);
+
+  a.errback('oh noes');
+  assertEquals(0, count);
+}
+
+
+function testNesting() {
+
+  function upperCase(res) {
+    return res.toUpperCase();
+  }
+
+  // Concatenates a list of callback or errback results into a single string.
+  function combine(res) {
+    return goog.array.map(res, function(result) {
+      return result[1];
+    }).join('');
+  }
+
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+  var d = new Deferred();
+
+  a.addCallback(upperCase);
+  b.addCallback(upperCase);
+  c.addCallback(upperCase);
+  d.addCallback(upperCase);
+
+  var dl1 = new DeferredList([a, b]);
+  var dl2 = new DeferredList([c, d]);
+
+  dl1.addCallback(combine);
+  dl2.addCallback(combine);
+
+  var dl3 = new DeferredList([dl1, dl2]);
+  dl3.addCallback(combine);
+  dl3.addCallback(function(res) {
+    assertEquals('AbCd', res);
+  });
+
+  addCatchAll(dl1, dl2, dl3);
+
+  a.callback('a');
+  c.callback('c');
+  b.errback('b');
+  d.errback('d');
+}
+
+
+function testGatherResults() {
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+
+  var dl = DeferredList.gatherResults([a, b, c]);
+
+  dl.addCallback(function(res) {
+    assertArrayEquals(['A', 'B', 'C'], res);
+  });
+
+  addCatchAll(dl);
+
+  b.callback('B');
+  a.callback('A');
+  c.callback('C');
+}
+
+
+function testGatherResultsFailure() {
+  var a = new Deferred();
+  var b = new Deferred();
+  var c = new Deferred();
+
+  var dl = DeferredList.gatherResults([a, b, c]);
+
+  var firedErrback = false;
+  var firedCallback = false;
+  dl.addCallback(function() {
+    firedCallback = true;
+  });
+  dl.addErrback(function() {
+    firedErrback = true;
+    return true;
+  });
+
+  addCatchAll(dl);
+
+  b.callback('B');
+  a.callback('A');
+  c.errback();
+
+  assertTrue('Errback should be called', firedErrback);
+  assertFalse('Callback should not be called', firedCallback);
+}
+
+
+function testGatherResults_cancelCancelsChildren() {
+  var cancelled = [];
+  var a = new Deferred(function() {
+    cancelled.push('a');
+  });
+  var b = new Deferred(function() {
+    cancelled.push('b');
+  });
+  var c = new Deferred(function() {
+    cancelled.push('c');
+  });
+
+  var dl = new DeferredList([a, b, c]);
+
+  var firedErrback = false;
+  var firedCallback = false;
+  dl.addCallback(function() {
+    firedCallback = true;
+  });
+  dl.addErrback(function() {
+    firedErrback = true;
+    return true;
+  });
+
+  addCatchAll(dl);
+
+  b.callback('b');
+  dl.cancel();
+
+  assertTrue('Errback should be called', firedErrback);
+  assertFalse('Callback should not be called', firedCallback);
+  assertArrayEquals(['a', 'c'], cancelled);
+}
+
+
+function testErrorCancelsPendingChildrenWhenFireOnFirstError() {
+  var cancelled = [];
+  var a = new Deferred(function() {
+    cancelled.push('a');
+  });
+  var b = new Deferred(function() {
+    cancelled.push('b');
+  });
+  var c = new Deferred(function() {
+    cancelled.push('c');
+  });
+
+  var dl = new DeferredList([a, b, c], false, true);
+
+  var firedErrback = false;
+  var firedCallback = false;
+  dl.addCallback(function() {
+    firedCallback = true;
+  });
+  dl.addErrback(function() {
+    firedErrback = true;
+    return true;
+  });
+
+  addCatchAll(dl);
+
+  a.callback('a')
+  b.errback();
+
+  assertTrue('Errback should be called', firedErrback);
+  assertFalse('Callback should not be called', firedCallback);
+  assertArrayEquals('Only C should be cancelled since A and B finished.',
+      ['c'], cancelled);
+}
+
+
+function testErrorDoesNotCancelPendingChildrenForVanillaLists() {
+  var cancelled = [];
+  var a = new Deferred(function() {
+    cancelled.push('a');
+  });
+  var b = new Deferred(function() {
+    cancelled.push('b');
+  });
+  var c = new Deferred(function() {
+    cancelled.push('c');
+  });
+
+  var dl = new DeferredList([a, b, c]);
+
+  var firedErrback = false;
+  var firedCallback = false;
+  dl.addCallback(function() {
+    firedCallback = true;
+  });
+  dl.addErrback(function() {
+    firedErrback = true;
+    return true;
+  });
+
+  addCatchAll(dl);
+
+  a.callback('a')
+  b.errback();
+  c.callback('c')
+
+  assertFalse('Errback should not be called', firedErrback);
+  assertTrue('Callback should be called', firedCallback);
+  assertArrayEquals('No cancellations', [], cancelled);
+}
+
+</script>
+</body>
+</html>

data/closure-library/third_party/closure/goog/osapi/osapi.js

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * @fileoverview Base OSAPI binding.
+ * This file was copied from
+ * http://svn.apache.org/repos/asf/shindig/trunk/features/src/main/javascript/features/shindig.container/osapi.js
+ * and it's slightly modified for closue.
+ */
+
+goog.provide('goog.osapi');
+
+
+// Expose osapi from container side.
+var osapi = osapi || {};
+goog.exportSymbol('osapi', osapi);
+
+
+/**
+ * Dispatch a JSON-RPC batch request to services defined in the osapi namespace
+ * @param {Array.<Object>} requests an array of rpc requests.
+ */
+goog.osapi.handleGadgetRpcMethod = function(requests) {
+  var responses = new Array(requests.length);
+  var callCount = 0;
+  var callback = osapi.callback;
+  var dummy = function(params, apiCallback) {
+    apiCallback({});
+  };
+  for (var i = 0; i < requests.length; i++) {
+    // Don't allow underscores in any part of the method name as a
+    // convention for restricted methods
+    var current = osapi;
+    if (requests[i]['method'].indexOf('_') == -1) {
+      var path = requests[i]['method'].split('.');
+      for (var j = 0; j < path.length; j++) {
+        if (current.hasOwnProperty(path[j])) {
+          current = current[path[j]];
+        } else {
+          // No matching api
+          current = dummy;
+          break;
+        }
+      }
+    } else {
+      current = dummy;
+    }
+
+    // Execute the call and latch the rpc callback until all
+    // complete
+    current(requests[i]['params'], function(i) {
+      return function(response) {
+        // Put back in json-rpc format
+        responses[i] = {'id': requests[i].id, 'data': response};
+        callCount++;
+        if (callCount == requests.length) {
+          callback(responses);
+        }
+      };
+    }(i));
+  }
+};
+
+
+/**
+ * Initializes container side osapi binding.
+ */
+goog.osapi.init = function() {
+   // Container-side binding for the gadgetsrpctransport used by osapi.
+   // Containers add services to the client-side osapi implementation by
+   // defining them in the osapi namespace
+  if (gadgets && gadgets.rpc) { // Only define if gadgets rpc exists
+    // Register the osapi RPC dispatcher.
+    gadgets.rpc.register('osapi._handleGadgetRpcMethod',
+        goog.osapi.handleGadgetRpcMethod);
+  }
+};

data/closure-library/third_party/closure/goog/silverlight/AppManifest.xml

@@ -0,0 +1,6 @@
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+>
+    <Deployment.Parts>
+    </Deployment.Parts>
+</Deployment>