Merge lp:~sidnei/lazr-js/prefetch into lp:lazr-js

[Sidnei da Silva]

This is a copy of the refactored prefetch code from Landscape. It can be used to defer calls to use() until one or more combo files containing YUI modules are loaded (in parallel!) so that the YUI loader doesn't try to re-fetch them.

[Māris Fogels (mars)]

Hi Sidnei,

This branch looks good. I think you have an indentation error on line 21, and another error on line 24. Instead of this:

15 +YUI.prototype.prefetch = function prefetch() {
16 + var Y = this,
17 + deferred = [],
18 + preload = arguments,
19 + pending = arguments.length;
20 +
21 + var YArray = Y.Array,
22 + YGet_script = Y.Get.script;
23 +
24 + /**

It should be this:

15 +YUI.prototype.prefetch = function prefetch() {
16 + var Y = this,
17 + deferred = [],
18 + preload = arguments,
19 + pending = arguments.length;
20 +
21 + var YArray = Y.Array, <== Indented
22 + YGet_script = Y.Get.script;
23 +
24 + /** <== Indented

Besides that, this code looks good. r=mars

review: Approve

[lp:~sidnei/lazr-js/prefetch]

189. By Sidnei da Silva on 2010-09-27

- Fix indentation.

190. By Sidnei da Silva on 2010-09-27

- Minify even more

191. By Sidnei da Silva on 2010-09-27

- Fix style of the copyright notice

=== added directory 'src-js/lazrjs/loader'
=== added file 'src-js/lazrjs/loader/prefetch.js'
--- src-js/lazrjs/loader/prefetch.js	1970-01-01 00:00:00 +0000
+++ src-js/lazrjs/loader/prefetch.js	2010-09-27 14:15:55 +0000
@@ -0,0 +1,87 @@
+/* Copyright (c) 2010, Canonical Ltd. All rights reserved. */
+
+/**
+ * Prefetch a set of files, deferring calls to 'use' until the
+ * preloaded files are finished loading.
+ *
+ * @public
+ */
+
+YUI.prototype.prefetch = function prefetch() {
+    var Y = this,
+        deferred = [],
+        preload = arguments,
+        pending = arguments.length;
+
+    var YArray_each = Y.Array.each,
+        YGet_script = Y.Get.script;
+
+    /**
+     * Wrap the native 'use' function to add some smarts around
+     * our custom loading of the rolled-up minified files so that
+     * we delay the loader from firing until the rolled-up files
+     * are finished loading, in order to avoid loading the
+     * modules twice.
+     */
+    var native_use = Y.use;
+
+    /* Now replace the original 'use' function with our own. */
+    Y.use = function use() {
+        /**
+         * If all external dependencies have been loaded, just
+         * call the native 'use' function directly.
+         */
+        if (!pending) {
+            native_use.apply(Y, arguments);
+        } else {
+            /**
+             * If there are things still loading, queue calls to 'use'
+             *  until they are finished.
+             */
+            var ridx = arguments.length,
+            args = [];
+            /* Make a copy of the original arguments. */
+            while (--ridx >= 0) {
+                args[ridx] = arguments[ridx];
+            }
+
+            /* Push copied arguments into the queue. */
+            deferred.push(args);
+        }
+    };
+
+    /**
+     * For each item to be preloaded, use the Y.Get utility to
+     * fetch the script (which might fetch them in parallel). When
+     * all the scripts are finished loading, we'll process the
+     * deferred calls to use with the native 'use' function.
+     */
+    YArray_each(preload, function(value) {
+        YGet_script(value, {onEnd: function() {
+            /**
+             * Once an item has finished preloading, we decrement
+             * the pending variable. Once it reaches zero, we
+             * know all preload items have finished loading.
+             */
+            pending--;
+
+            /**
+             * Once we're done, restore the original 'use'
+             * function and call all of the deferred callbacks in
+             * their original order.
+             */
+            if (!pending) {
+                Y.use = native_use;
+
+                /**
+                 * Attach the 'loader' module, which *should* be
+                 * already loaded by now.
+                 */
+                Y._attach(["loader"]);
+                YArray_each(deferred, function(value) {
+                    native_use.apply(this, value);
+                });
+            }
+        }, attributes: {defer: "defer"}});
+    });
+};