RubyGems - middleman-wizard-template - Versions diffs - 1.0.0.pre.1 - Mend

middleman-wizard-template 1.0.0.pre.1

Files changed (1739) hide show

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/moduleinfo_test.html ADDED Viewed

@@ -0,0 +1,108 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<!--
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.module.ModuleInfo</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.module.BaseModule');
+  goog.require('goog.module.ModuleInfo');
+  goog.require('goog.module.ModuleManager');
+  goog.require('goog.testing.jsunit');
+  goog.require('goog.testing.MockClock');
+</script>
+</head>
+<body>
+<script type="text/javascript">
+  /**
+   * Test initial state of module info.
+   */
+  function testNotLoadedAtStart() {
+    var m = new goog.module.ModuleInfo();
+    assertFalse('Shouldn\'t be loaded', m.isLoaded());
+  }
+  var TestModule = function() {
+    goog.module.BaseModule.call(this);
+  };
+  goog.inherits(TestModule, goog.module.BaseModule);
+  /**
+   * Test loaded module info.
+   */
+  function testOnLoad() {
+    var m = new goog.module.ModuleInfo();
+    m.setModuleConstructor(TestModule);
+    m.onLoad(goog.nullFunction);
+    assertTrue(m.isLoaded());
+    var module = m.getModule();
+    assertNotNull(module);
+    assertTrue(module instanceof TestModule);
+    m.dispose();
+    assertTrue(m.isDisposed());
+    assertTrue('Disposing of ModuleInfo should dispose of its module',
+        module.isDisposed());
+  }
+  /**
+   * Test callbacks on module load.
+   */
+  function testCallbacks() {
+    var m = new goog.module.ModuleInfo();
+    m.setModuleConstructor(TestModule);
+    var index = 0;
+    var a = -1, b = -1, c = -1, d = -1;
+    var ca = m.registerCallback(function() { a = index++; })
+    var cb = m.registerCallback(function() { b = index++; })
+    var cc = m.registerCallback(function() { c = index++; })
+    var cd = m.registerEarlyCallback(function() { d = index++; })
+    cb.abort();
+    m.onLoad(goog.nullFunction);
+    assertTrue('callback A should have fired', a >= 0);
+    assertFalse('callback B should have been aborted', b >= 0);
+    assertTrue('callback C should have fired', c >= 0);
+    assertTrue('early callback d should have fired', d >= 0);
+    assertEquals('ordering of callbacks was wrong', 0, d);
+    assertEquals('ordering of callbacks was wrong', 1, a);
+    assertEquals('ordering of callbacks was wrong', 2, c);
+  }
+  /**
+   * Tests the error callbacks.
+   */
+  function testErrbacks() {
+    var m = new goog.module.ModuleInfo();
+    m.setModuleConstructor(TestModule);
+    var index = 0;
+    var a = -1, b = -1, c = -1, d = -1;
+    var ca = m.registerErrback(function() { a = index++; })
+    var cb = m.registerErrback(function() { b = index++; })
+    var cc = m.registerErrback(function() { c = index++; })
+    m.onError('foo');
+    assertTrue('callback A should have fired', a >= 0);
+    assertTrue('callback B should have fired', b >= 0);
+    assertTrue('callback C should have fired', c >= 0);
+    assertEquals('ordering of callbacks was wrong', 0, a);
+    assertEquals('ordering of callbacks was wrong', 1, b);
+    assertEquals('ordering of callbacks was wrong', 2, c);
+  }
+</script>
+</body>
+</html>

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/moduleloadcallback.js ADDED Viewed

@@ -0,0 +1,84 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed 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 A simple callback mechanism for notification about module
+ * loads. Should be considered package-private to goog.module.
+ *
+ */
+goog.provide('goog.module.ModuleLoadCallback');
+goog.require('goog.debug.entryPointRegistry');
+goog.require('goog.debug.errorHandlerWeakDep');
+/**
+ * Class used to encapsulate the callbacks to be called when a module loads.
+ * @param {Function} fn Callback function.
+ * @param {Object=} opt_handler Optional handler under whose scope to execute
+ *     the callback.
+ * @constructor
+ */
+goog.module.ModuleLoadCallback = function(fn, opt_handler) {
+  /**
+   * Callback function.
+   * @type {Function}
+   * @private
+   */
+  this.fn_ = fn;
+  /**
+   * Optional handler under whose scope to execute the callback.
+   * @type {Object|undefined}
+   * @private
+   */
+  this.handler_ = opt_handler;
+};
+/**
+ * Completes the operation and calls the callback function if appropriate.
+ * @param {*} context The module context.
+ */
+goog.module.ModuleLoadCallback.prototype.execute = function(context) {
+  if (this.fn_) {
+    this.fn_.call(this.handler_ || null, context);
+    this.handler_ = null;
+    this.fn_ = null;
+  }
+};
+/**
+ * Abort the callback, but not the actual module load.
+ */
+goog.module.ModuleLoadCallback.prototype.abort = function() {
+  this.fn_ = null;
+  this.handler_ = null;
+};
+// Register the browser event handler as an entry point, so that
+// it can be monitored for exception handling, etc.
+goog.debug.entryPointRegistry.register(
+    /**
+     * @param {function(!Function): !Function} transformer The transforming
+     *     function.
+     */
+    function(transformer) {
+      goog.module.ModuleLoadCallback.prototype.execute =
+          transformer(goog.module.ModuleLoadCallback.prototype.execute);
+    });

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/moduleloadcallback_test.html ADDED Viewed

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2010 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+Author: nicksantos@google.com (Nick Santos)
+-->
+<html>
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>JsUnit tests for goog.module.ModuleLoadCallback</title>
+<script src="../base.js"></script>
+<script>
+goog.require('goog.debug.ErrorHandler');
+goog.require('goog.debug.entryPointRegistry');
+goog.require('goog.functions');
+goog.require('goog.module.ModuleLoadCallback');
+goog.require('goog.testing.jsunit');
+goog.require('goog.testing.recordFunction');
+</script>
+</head>
+<body>
+<script type='text/javascript'>
+function testProtectEntryPoint() {
+  // Test a callback created before the protect method is called.
+  var callback1 = new goog.module.ModuleLoadCallback(
+      goog.functions.error('callback1'));
+  var errorFn = goog.testing.recordFunction();
+  var errorHandler = new goog.debug.ErrorHandler(errorFn);
+  goog.debug.entryPointRegistry.monitorAll(errorHandler);
+  assertEquals(0, errorFn.getCallCount());
+  assertThrows(goog.bind(callback1.execute, callback1));
+  assertEquals(1, errorFn.getCallCount());
+  assertContains('callback1', errorFn.getLastCall().getArguments()[0].message);
+  // Test a callback created after the protect method is called.
+  var callback2 = new goog.module.ModuleLoadCallback(
+      goog.functions.error('callback2'));
+  assertThrows(goog.bind(callback1.execute, callback2));
+  assertEquals(2, errorFn.getCallCount());
+  assertContains('callback2', errorFn.getLastCall().getArguments()[0].message);
+}
+</script>
+</body>
+</html>

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/moduleloader.js ADDED Viewed

@@ -0,0 +1,436 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed 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 The module loader for loading modules across the network.
+ *
+ * Browsers do not guarantee that scripts appended to the document
+ * are executed in the order they are added. For production mode, we use
+ * XHRs to load scripts, because they do not have this problem and they
+ * have superior mechanisms for handling failure. However, XHR-evaled
+ * scripts are harder to debug.
+ *
+ * In debugging mode, we use normal script tags. In order to make this work,
+ * we load the scripts in serial: we do not execute script B to the document
+ * until we are certain that script A is finished loading.
+ *
+ */
+goog.provide('goog.module.ModuleLoader');
+goog.require('goog.Timer');
+goog.require('goog.array');
+goog.require('goog.debug.Logger');
+goog.require('goog.events');
+goog.require('goog.events.Event');
+goog.require('goog.events.EventHandler');
+goog.require('goog.events.EventTarget');
+goog.require('goog.module.AbstractModuleLoader');
+goog.require('goog.net.BulkLoader');
+goog.require('goog.net.EventType');
+goog.require('goog.net.jsloader');
+/**
+ * A class that loads Javascript modules.
+ * @constructor
+ * @extends {goog.events.EventTarget}
+ * @implements {goog.module.AbstractModuleLoader}
+ */
+goog.module.ModuleLoader = function() {
+  goog.base(this);
+  /**
+   * Event handler for managing handling events.
+   * @type {goog.events.EventHandler}
+   * @private
+   */
+  this.eventHandler_ = new goog.events.EventHandler(this);
+  /**
+   * A map from module IDs to goog.module.ModuleLoader.LoadStatus.
+   * @type {!Object.<Array.<string>, goog.module.ModuleLoader.LoadStatus>}
+   * @private
+   */
+  this.loadingModulesStatus_ = {};
+};
+goog.inherits(goog.module.ModuleLoader, goog.events.EventTarget);
+/**
+ * A logger.
+ * @type {goog.debug.Logger}
+ * @protected
+ */
+goog.module.ModuleLoader.prototype.logger = goog.debug.Logger.getLogger(
+    'goog.module.ModuleLoader');
+/**
+ * Whether debug mode is enabled.
+ * @type {boolean}
+ * @private
+ */
+goog.module.ModuleLoader.prototype.debugMode_ = false;
+/**
+ * Whether source url injection is enabled.
+ * @type {boolean}
+ * @private
+ */
+goog.module.ModuleLoader.prototype.sourceUrlInjection_ = false;
+/**
+ * Gets the debug mode for the loader.
+ * @return {boolean} debugMode Whether the debug mode is enabled.
+ */
+goog.module.ModuleLoader.prototype.getDebugMode = function() {
+  return this.debugMode_;
+};
+/**
+ * Sets the debug mode for the loader.
+ * @param {boolean} debugMode Whether the debug mode is enabled.
+ */
+goog.module.ModuleLoader.prototype.setDebugMode = function(debugMode) {
+  this.debugMode_ = debugMode;
+};
+/**
+ * When enabled, we will add a sourceURL comment to the end of all scripts
+ * to mark their origin.
+ *
+ * Notice that in most cases, this is far superior to debug mode, because
+ * the scripts will load faster on most browsers. (Debug mode is very slow.
+ * See the comment at the top of this file.)
+ *
+ * On WebKit, stack traces will refect the sourceURL comment, so this is also
+ * useful for debugging webkit stack traces in production.
+ *
+ * There is some performance overhead to doing this.
+ *
+ * TODO(nicksantos): Measure the performance cost, and figure out a decision
+ * tree for when users should turn this on. I'm not sure if most users are
+ * sophisticated enough to know whether they want this or not, because
+ * there are a couple different trade-offs involved. We might want to make
+ * debug mode do this on browsers that support sourceURL.
+ *
+ * @param {boolean} enabled Whether source url injection is enabled.
+ * @see http://bugzilla.mozilla.org/show_bug.cgi?id=583083
+ */
+goog.module.ModuleLoader.prototype.setSourceUrlInjection = function(enabled) {
+  this.sourceUrlInjection_ = enabled;
+};
+/** @return {boolean} Whether we're using source url injection. */
+goog.module.ModuleLoader.prototype.usingSourceUrlInjection = function() {
+  return this.sourceUrlInjection_;
+};
+/** @override */
+goog.module.ModuleLoader.prototype.loadModules = function(
+    ids, moduleInfoMap, opt_successFn, opt_errorFn, opt_timeoutFn,
+    opt_forceReload) {
+  var loadStatus = this.loadingModulesStatus_[ids] ||
+      new goog.module.ModuleLoader.LoadStatus();
+  loadStatus.loadRequested = true;
+  loadStatus.successFn = opt_successFn || null;
+  loadStatus.errorFn = opt_errorFn || null;
+  if (!this.loadingModulesStatus_[ids]) {
+    // Modules were not prefetched.
+    this.loadingModulesStatus_[ids] = loadStatus;
+    this.downloadModules_(ids, moduleInfoMap);
+    // TODO(user): Need to handle timeouts in the module loading code.
+  } else if (goog.isDefAndNotNull(loadStatus.responseTexts)) {
+    // Modules prefetch is complete.
+    this.evaluateCode_(ids);
+  }
+  // Otherwise modules prefetch is in progress, and these modules will be
+  // executed after the prefetch is complete.
+};
+/**
+ * Evaluate the JS code.
+ * @param {Array.<string>} moduleIds The module ids.
+ * @private
+ */
+goog.module.ModuleLoader.prototype.evaluateCode_ = function(moduleIds) {
+  this.dispatchEvent(new goog.module.ModuleLoader.Event(
+      goog.module.ModuleLoader.EventType.REQUEST_SUCCESS, moduleIds));
+  this.logger.info('evaluateCode ids:' + moduleIds);
+  var success = true;
+  var loadStatus = this.loadingModulesStatus_[moduleIds];
+  var uris = loadStatus.requestUris;
+  var texts = loadStatus.responseTexts;
+  try {
+    if (this.usingSourceUrlInjection()) {
+      for (var i = 0; i < uris.length; i++) {
+        var uri = uris[i];
+        goog.globalEval(texts[i] + ' //@ sourceURL=' + uri);
+      }
+    } else {
+      goog.globalEval(texts.join('\n'));
+    }
+  } catch (e) {
+    success = false;
+    // TODO(user): Consider throwing an exception here.
+    this.logger.warning('Loaded incomplete code for module(s): ' +
+        moduleIds, e);
+  }
+  this.dispatchEvent(
+      new goog.module.ModuleLoader.Event(
+          goog.module.ModuleLoader.EventType.EVALUATE_CODE, moduleIds));
+  if (!success) {
+    this.handleErrorHelper_(moduleIds, loadStatus.errorFn, null /* status */);
+  } else if (loadStatus.successFn) {
+    loadStatus.successFn();
+  }
+  delete this.loadingModulesStatus_[moduleIds];
+};
+/**
+ * Handles a successful response to a request for prefetch or load one or more
+ * modules.
+ *
+ * @param {goog.net.BulkLoader} bulkLoader The bulk loader.
+ * @param {Array.<string>} moduleIds The ids of the modules requested.
+ * @private
+ */
+goog.module.ModuleLoader.prototype.handleSuccess_ = function(
+    bulkLoader, moduleIds) {
+  this.logger.info('Code loaded for module(s): ' + moduleIds);
+  var loadStatus = this.loadingModulesStatus_[moduleIds];
+  loadStatus.responseTexts = bulkLoader.getResponseTexts();
+  if (loadStatus.loadRequested) {
+    this.evaluateCode_(moduleIds);
+  }
+  // NOTE: A bulk loader instance is used for loading a set of module ids.
+  // Once these modules have been loaded successfully or in error the bulk
+  // loader should be disposed as it is not needed anymore. A new bulk loader
+  // is instantiated for any new modules to be loaded. The dispose is called
+  // on a timer so that the bulkloader has a chance to release its
+  // objects.
+  goog.Timer.callOnce(bulkLoader.dispose, 5, bulkLoader);
+};
+/** @override */
+goog.module.ModuleLoader.prototype.prefetchModule = function(
+    id, moduleInfo) {
+  // Do not prefetch in debug mode.
+  if (this.getDebugMode()) {
+    return;
+  }
+  var loadStatus = this.loadingModulesStatus_[[id]];
+  if (loadStatus) {
+    return;
+  }
+  var moduleInfoMap = {};
+  moduleInfoMap[id] = moduleInfo;
+  this.loadingModulesStatus_[[id]] = new goog.module.ModuleLoader.LoadStatus();
+  this.downloadModules_([id], moduleInfoMap);
+};
+/**
+ * Downloads a list of JavaScript modules.
+ *
+ * @param {Array.<string>} ids The module ids in dependency order.
+ * @param {Object} moduleInfoMap A mapping from module id to ModuleInfo object.
+ * @private
+ */
+goog.module.ModuleLoader.prototype.downloadModules_ = function(
+    ids, moduleInfoMap) {
+  var uris = [];
+  for (var i = 0; i < ids.length; i++) {
+    goog.array.extend(uris, moduleInfoMap[ids[i]].getUris());
+  }
+  this.logger.info('downloadModules ids:' + ids + ' uris:' + uris);
+  if (this.getDebugMode()) {
+    // In debug mode use <script> tags rather than XHRs to load the files.
+    // This makes it possible to debug and inspect stack traces more easily.
+    // It's also possible to use it to load JavaScript files that are hosted on
+    // another domain.
+    goog.net.jsloader.loadMany(uris);
+  } else {
+    var loadStatus = this.loadingModulesStatus_[ids];
+    loadStatus.requestUris = uris;
+    var bulkLoader = new goog.net.BulkLoader(uris);
+    var eventHandler = this.eventHandler_;
+    eventHandler.listen(
+        bulkLoader,
+        goog.net.EventType.SUCCESS,
+        goog.bind(this.handleSuccess_, this, bulkLoader, ids),
+        false,
+        null);
+    eventHandler.listen(
+        bulkLoader,
+        goog.net.EventType.ERROR,
+        goog.bind(this.handleError_, this, bulkLoader, ids),
+        false,
+        null);
+    bulkLoader.load();
+  }
+};
+/**
+ * Handles an error during a request for one or more modules.
+ * @param {goog.net.BulkLoader} bulkLoader The bulk loader.
+ * @param {Array.<string>} moduleIds The ids of the modules requested.
+ * @param {number} status The response status.
+ * @private
+ */
+goog.module.ModuleLoader.prototype.handleError_ = function(
+    bulkLoader, moduleIds, status) {
+  var loadStatus = this.loadingModulesStatus_[moduleIds];
+  // The bulk loader doesn't cancel other requests when a request fails. We will
+  // delete the loadStatus in the first failure, so it will be undefined in
+  // subsequent errors.
+  if (loadStatus) {
+    delete this.loadingModulesStatus_[moduleIds];
+    this.handleErrorHelper_(moduleIds, loadStatus.errorFn, status);
+  }
+  // NOTE: A bulk loader instance is used for loading a set of module ids. Once
+  // these modules have been loaded successfully or in error the bulk loader
+  // should be disposed as it is not needed anymore. A new bulk loader is
+  // instantiated for any new modules to be loaded. The dispose is called
+  // on another thread so that the bulkloader has a chance to release its
+  // objects.
+  goog.Timer.callOnce(bulkLoader.dispose, 5, bulkLoader);
+};
+/**
+ * Handles an error during a request for one or more modules.
+ * @param {Array.<string>} moduleIds The ids of the modules requested.
+ * @param {?function(?number)} errorFn The function to call on failure.
+ * @param {?number} status The response status.
+ * @private
+ */
+goog.module.ModuleLoader.prototype.handleErrorHelper_ = function(
+    moduleIds, errorFn, status) {
+  this.dispatchEvent(
+      new goog.module.ModuleLoader.Event(
+          goog.module.ModuleLoader.EventType.REQUEST_ERROR, moduleIds));
+  this.logger.warning('Request failed for module(s): ' + moduleIds);
+  if (errorFn) {
+    errorFn(status);
+  }
+};
+/** @override */
+goog.module.ModuleLoader.prototype.disposeInternal = function() {
+  goog.module.ModuleLoader.superClass_.disposeInternal.call(this);
+  this.eventHandler_.dispose();
+  this.eventHandler_ = null;
+};
+/**
+ * @enum {string}
+ */
+goog.module.ModuleLoader.EventType = {
+  /** Called after the code for a module is evaluated. */
+  EVALUATE_CODE: goog.events.getUniqueId('evaluateCode'),
+  /** Called when the BulkLoader finishes successfully. */
+  REQUEST_SUCCESS: goog.events.getUniqueId('requestSuccess'),
+  /** Called when the BulkLoader fails, or code loading fails. */
+  REQUEST_ERROR: goog.events.getUniqueId('requestError')
+};
+/**
+ * @param {goog.module.ModuleLoader.EventType} type The type.
+ * @param {Array.<string>} moduleIds The ids of the modules being evaluated.
+ * @constructor
+ * @extends {goog.events.Event}
+ */
+goog.module.ModuleLoader.Event = function(type, moduleIds) {
+  goog.base(this, type);
+  /**
+   * @type {Array.<string>}
+   */
+  this.moduleIds = moduleIds;
+};
+goog.inherits(goog.module.ModuleLoader.Event, goog.events.Event);
+/**
+ * A class that keeps the state of the module during the loading process. It is
+ * used to save loading information between modules download and evaluation.
+ * @constructor
+ */
+goog.module.ModuleLoader.LoadStatus = function() {
+  /**
+   * The request uris.
+   * @type {Array.<string>}
+   */
+  this.requestUris = null;
+  /**
+   * The response texts.
+   * @type {Array.<string>}
+   */
+  this.responseTexts = null;
+  /**
+   * Whether loadModules was called for the set of modules referred by this
+   * status.
+   * @type {boolean}
+   */
+  this.loadRequested = false;
+  /**
+   * Success callback.
+   * @type {?function()}
+   */
+  this.successFn = null;
+  /**
+   * Error callback.
+   * @type {?function(?number)}
+   */
+  this.errorFn = null;
+};