Improve addons loading with consumes/provides

Author: SamyPesse

addons/editor/addon-built.js

@@ -108,4 +108,9 @@ define([
 
     // Open base tabs
     commands.run("files.open");
+
+    // Return globals
+    return {
+        'ace': ace
+    };
 });

addons/editor/client.js

@@ -11,6 +11,9 @@
         "url": "http://samypesse.fr"
     },
     "client": {
-        "main": "client"
+        "main": "client",
+        "provides": [
+            "ace"
+        ]
     }
 }

addons/editor/package.json

@@ -67,5 +67,8 @@ exports.config = {
     },
     'args': {
         'version': pkg.version
+    },
+    'options': {
+        
     }
 };

client/build.js

@@ -11,6 +11,16 @@ define([
             loader: "getInstalled",
             loaderArgs: [],
         }, hr.Collection.prototype.defaults),
+
+        // Constructor
+        initialize: function() {
+            Addons.__super__.initialize.apply(this, arguments);
+
+            this.resolved = {};
+            this.provides = {};
+
+            return this;
+        },
 
         // Get installed addons
         getInstalled: function(options) {
@@ -70,11 +80,92 @@ define([
             });
         },
 
+        // Extract from engineer, order addons for loading
+        checkCycles: function() {
+            var that = this;
+            var plugins = this.map(function(addon, index) {
+                return {
+                    name: addon.get("name"),
+                    provides: addon.get("client.provides", []).concat(),
+                    consumes: addon.get("client.consumes", []).concat(),
+                    i: index
+                };
+            });
+
+            var changed = true;
+            var sorted = [];
+
+            while(plugins.length && changed) {
+                changed = false;
+
+                plugins.concat().forEach(function(plugin) {
+                    var consumes = plugin.consumes.concat();
+
+                    var resolvedAll = true;
+                    for (var i=0; i<consumes.length; i++) {
+                        var service = consumes[i];
+                        if (!that.resolved[service]) {
+                            resolvedAll = false;
+                        } else {
+                            plugin.consumes.splice(plugin.consumes.indexOf(service), 1);
+                        }
+                    }
+
+                    if (!resolvedAll)
+                        return;
+
+                    plugins.splice(plugins.indexOf(plugin), 1);
+                    plugin.provides.forEach(function(service) {
+                        that.resolved[service] = true;
+                    });
+                    sorted.push(that.models[plugin.i]);
+                    changed = true;
+                });
+            }
+
+            if (plugins.length) {
+                var unresolved = {};
+                plugins.forEach(function(plugin) {
+                    delete plugin.config;
+                    plugin.consumes.forEach(function(name) {
+                        if (unresolved[name] == false)
+                            return;
+                        if (!unresolved[name])
+                            unresolved[name] = [];
+                        unresolved[name].push(plugin.name);
+                    });
+                    plugin.provides.forEach(function(name) {
+                        unresolved[name] = false;
+                    });
+                });
+
+                Object.keys(unresolved).forEach(function(name) {
+                    if (unresolved[name] == false)
+                        delete unresolved[name];
+                });
+
+                console.error("Could not resolve dependencies of these plugins:", plugins);
+                console.error("Resolved services:", Object.keys(resolved));
+                console.error("Missing services:", unresolved);
+                throw new Error("Could not resolve dependencies");
+            }
+
+            return sorted;
+        },
+
         // Load all this addons collection
+        // similar loading to engineer
         loadAll: function() {
-            return Q.all(this.map(function(addon) {
-                return addon.load();
-            }));
+            var that = this;
+            var addons = this.checkCycles();
+
+            return _.reduce(addons, function(d, addon) {
+                return d.then(function() {
+                    return addon.load({}, _.pick(that.provides, addon.get("client.consumes", [])));
+                }).then(function(provides) {
+                    _.extend(that.provides, provides || {});
+                });
+            }, Q({}));
         }
     });
 

client/collections/addons.js

@@ -32,7 +32,7 @@ define([
         },
 
         // Load the addon
-        load: function() {
+        load: function(config, imports) {
             var context, main, addonRequireConfig,
             addonRequire, that = this
             var d = Q.defer();
@@ -68,14 +68,25 @@ define([
                 base: "/addons/"+this.get("name")+"/templates"
             });
 
-            // Load main module
-            addonRequire([main], function() {
+            // Register addons
+            var register = function(err, globals) {
+                if (err) {
+                    that.set("state", "error");
+                    d.reject(err);
+                    return;
+                }
                 that.set("state", "loaded");
-                d.resolve();
-            }, function(err) {
-                that.set("state", "error");
-                d.reject(err);
-            });
+                d.resolve(globals);
+            };
+
+            // Load main module
+            addonRequire([main], function(globals) {
+                if (_.isFunction(globals)) {
+                    globals(config, imports, register);
+                } else {
+                    register(null, globals);
+                }
+            }, register);
 
             return d.promise;
         }