More bootstrap work. Now loadable without restart.

--HG--
branch : bootstrapped
rename : common/content/modules.js => common/modules/overlay.jsm

common/modules/base.jsm

@@ -152,8 +152,10 @@ defineModule.time = function time(major, minor, func, self) {
 
 function endModule() {
     defineModule.loadLog.push("endModule " + currentModule.NAME);
+
     for (let [, mod] in Iterator(use[currentModule.NAME] || []))
         require(mod, currentModule.NAME, "use");
+
     loaded[currentModule.NAME] = 1;
 }
 

common/modules/overlay.jsm

@@ -0,0 +1,259 @@
+// Copyright (c) 2009-2010 by Kris Maglione <maglione.k@gmail.com>
+//
+// This work is licensed for reuse under an MIT license. Details are
+// given in the LICENSE.txt file included with this file.
+"use strict";
+
+Components.utils.import("resource://dactyl/base.jsm");
+defineModule("overlay", {
+    exports: ["ModuleBase"],
+    require: ["sanitizer", "services", "template", "util"],
+});
+
+/**
+ * @class ModuleBase
+ * The base class for all modules.
+ */
+const ModuleBase = Class("ModuleBase", {
+    /**
+     * @property {[string]} A list of module prerequisites which
+     * must be initialized before this module is loaded.
+     */
+    requires: [],
+
+    toString: function () "[module " + this.constructor.className + "]"
+});
+
+util.overlayWindow("chrome://browser/content/browser.xul", function (window) ({
+    init: function (document) {
+        /**
+         * @constructor Module
+         *
+         * Constructs a new ModuleBase class and makes arrangements for its
+         * initialization. Arguments marked as optional must be either
+         * entirely elided, or they must have the exact type specified.
+         * Loading semantics are as follows:
+         *
+         *  - A module is guaranteed not to be initialized before any of its
+         *    prerequisites as listed in its {@see ModuleBase#requires} member.
+         *  - A module is considered initialized once it's been instantiated,
+         *    its {@see Class#init} method has been called, and its
+         *    instance has been installed into the top-level {@see modules}
+         *    object.
+         *  - Once the module has been initialized, its module-dependent
+         *    initialization functions will be called as described hereafter.
+         * @param {string} name The module's name as it will appear in the
+         *     top-level {@see modules} object.
+         * @param {ModuleBase} base The base class for this module.
+         *     @optional
+         * @param {Object} prototype The prototype for instances of this
+         *     object. The object itself is copied and not used as a prototype
+         *     directly.
+         * @param {Object} classProperties The class properties for the new
+         *     module constructor.
+         *     @optional
+         * @param {Object} moduleInit The module initialization functions
+         *     for the new module. Each function is called as soon as the named module
+         *     has been initialized, but after the module itself. The constructors are
+         *     guaranteed to be called in the same order that the dependent modules
+         *     were initialized.
+         *     @optional
+         *
+         * @returns {function} The constructor for the resulting module.
+         */
+        function Module(name) {
+            let args = Array.slice(arguments);
+
+            var base = ModuleBase;
+            if (callable(args[1]))
+                base = args.splice(1, 1)[0];
+            let [, prototype, classProperties, moduleInit] = args;
+            const module = Class(name, base, prototype, classProperties);
+
+            module.INIT = moduleInit || {};
+            module.prototype.INIT = module.INIT;
+            module.requires = prototype.requires || [];
+            Module.list.push(module);
+            Module.constructors[name] = module;
+            return module;
+        }
+        Module.list = [];
+        Module.constructors = {};
+
+        const create = window.Object.create || function (proto) {
+            let res = window.Object();
+            object.__proto__ = proto;
+            return object;
+        }
+
+        const jsmodules = {};
+        const modules = update(create(jsmodules), {
+
+            jsmodules: jsmodules,
+
+            get content() this.config.browser.contentWindow || window.content,
+
+            window: window,
+
+            Module: Module,
+
+            load: function load(script) {
+                for (let [i, base] in Iterator(prefix)) {
+                    try {
+                        services.subscriptLoader.loadSubScript(base + script + ".js", modules, "UTF-8");
+                        return;
+                    }
+                    catch (e) {
+                        if (typeof e !== "string") {
+                            util.dump("Trying: " + (base + script + ".js") + ":");
+                            util.reportError(e);
+                        }
+                    }
+                }
+                try {
+                    Cu.import("resource://dactyl/" + script + ".jsm", jsmodules);
+                }
+                catch (e) {
+                    util.dump("Loading script " + script + ":");
+                    util.reportError(e);
+                }
+            },
+
+            newContext: function newContext(proto) {
+                let sandbox = Components.utils.Sandbox(window, { sandboxPrototype: proto || modules, wantXrays: false });
+                // Hack:
+                sandbox.Object = jsmodules.Object;
+                sandbox.Math = jsmodules.Math;
+                sandbox.__proto__ = proto || modules;
+                return sandbox;
+            }
+        });
+        modules.modules = modules;
+        window.dactyl = { modules: modules };
+
+        const BASE = "chrome://dactyl/content/";
+
+        let prefix = [BASE];
+
+        modules.load("util");
+        modules.load("services");
+        prefix.unshift("chrome://" + modules.services["dactyl:"].name + "/content/");
+
+        ["base",
+         "overlay",
+         "prefs",
+         "storage",
+         "javascript",
+         "dactyl",
+         "modes",
+         "abbreviations",
+         "autocommands",
+         "buffer",
+         "commandline",
+         "commands",
+         "completion",
+         "configbase",
+         "config",
+         "editor",
+         "events",
+         "finder",
+         "highlight",
+         "hints",
+         "io",
+         "mappings",
+         "marks",
+         "options",
+         "statusline",
+         "styles",
+         "template"
+         ].forEach(modules.load);
+
+        modules.Config.prototype.scripts.forEach(modules.load);
+    },
+    load: function (document) {
+        var { modules, Module } = window.dactyl.modules;
+        delete window.dactyl;
+
+        Module.list.forEach(function (module) {
+            modules.__defineGetter__(module.className, function () {
+                delete modules[module.className];
+                return load(module.className, null, Components.stack.caller);
+            });
+        });
+
+        const start = Date.now();
+        const deferredInit = { load: [] };
+        const seen = set();
+        const loaded = set(["init"]);
+        modules.loaded = loaded;
+
+        function init(module) {
+            function init(func, mod)
+                function () defineModule.time(module.className || module.constructor.className, mod,
+                                              func, module,
+                                              modules.dactyl, modules, window);
+
+            set.add(loaded, module.constructor.className);
+            for (let [mod, func] in Iterator(module.INIT)) {
+                if (mod in loaded)
+                    init(func, mod)();
+                else {
+                    deferredInit[mod] = deferredInit[mod] || [];
+                    deferredInit[mod].push(init(func, mod));
+                }
+            }
+        }
+        defineModule.modules.map(init);
+
+        function load(module, prereq, frame) {
+            if (isString(module)) {
+                if (!Module.constructors.hasOwnProperty(module))
+                    modules.load(module);
+                module = Module.constructors[module];
+            }
+
+            try {
+                if (module.className in loaded)
+                    return;
+                if (module.className in seen)
+                    throw Error("Module dependency loop.");
+                set.add(seen, module.className);
+
+                for (let dep in values(module.requires))
+                    load(Module.constructors[dep], module.className);
+
+                defineModule.loadLog.push("Load" + (isString(prereq) ? " " + prereq + " dependency: " : ": ") + module.className);
+                if (frame && frame.filename)
+                    defineModule.loadLog.push(" from: " + frame.filename + ":" + frame.lineNumber);
+
+                delete modules[module.className];
+                modules[module.className] = defineModule.time(module.className, "init", module);
+
+                init(modules[module.className]);
+                for (let [, fn] in iter(deferredInit[module.className] || []))
+                    fn();
+            }
+            catch (e) {
+                util.dump("Loading " + (module && module.className) + ":");
+                util.reportError(e);
+            }
+            return modules[module.className];
+        }
+
+        Module.list.forEach(load);
+        deferredInit["load"].forEach(call);
+        modules.times = update({}, defineModule.times);
+
+        util.dump("Loaded in " + (Date.now() - start) + "ms");
+
+        modules.events.addSessionListener(window, "unload", function onUnload() {
+            window.removeEventListener("unload", onUnload, false);
+            for (let [, mod] in iter(modules))
+                if (mod instanceof ModuleBase && "destroy" in mod)
+                    mod.destroy();
+        }, false);
+    }
+}));
+
+
+// vim: set fdm=marker sw=4 ts=4 et:

common/modules/sanitizer.jsm

@@ -12,6 +12,8 @@
 // FIXME:
 //   - finish 1.9.0 support if we're going to support sanitizing in Melodactyl
 
+try {
+
 Components.utils.import("resource://dactyl/base.jsm");
 defineModule("sanitizer", {
     exports: ["Range", "Sanitizer", "sanitizer"],
@@ -641,6 +643,6 @@ const Sanitizer = Module("sanitizer", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakR
 
 endModule();
 
-// catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);}
+} catch(e){dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack);}
 
 // vim: set fdm=marker sw=4 ts=4 et ft=javascript:

common/modules/util.jsm

@@ -908,6 +908,8 @@ const Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference])
         if (!window.dactylOverlays)
             window.dactylOverlays = [];
 
+        util.dump("load overlays", window.document.documentURI);
+
         for each (let obj in util.overlays[window.document.documentURI] || []) {
             if (window.dactylOverlays.indexOf(obj) >= 0)
                 continue;
@@ -979,6 +981,7 @@ const Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference])
         },
         "toplevel-window-ready": function (window, data) {
             window.addEventListener("DOMContentLoaded", wrapCallback(function listener(event) {
+                window.dactylDOMLoaded = false;
                 if (event.originalTarget === window.document) {
                     window.removeEventListener("DOMContentLoaded", listener.wrapper, true);
                     window.document.dactylDOMLoaded = event;
@@ -998,9 +1001,13 @@ const Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference])
                 this.overlays[url].push(fn);
             }, this);
 
-            for (let win in iter(services.windowMediator.getEnumerator(null)))
-                if (win.document.dactylDOMLoaded)
+            for (let win in iter(services.windowMediator.getEnumerator(null))) {
+                util.dump("checkOverlay", win.document.dactylDOMLoaded, win.document.location.href);
+                if (win.document.dactylDOMLoaded || win.dactylDOMLoaded !== false)
                     this._loadOverlays(win);
+                else
+                    this.observe(win, "toplevel-window-ready");
+            }
         }
     },
 
@@ -1152,8 +1159,11 @@ const Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference])
             this.dump("");
         }
         catch (e) {
-            this.dump(e);
-            try { util.dump(e.stack) } catch (e) {}
+            try {
+                this.dump(String(error));
+                this.dump(error.stack)
+            }
+            catch (e) { dump(e + "\n"); }
         }
     },