Ticket #3318: 3318.patch

_source/core/plugins.js

@@ -52 +52 @@
                                                         loadPlugins.call( this, requiredPlugins );
                                                 else
                                                 {
+                                                        // Determine the order of initialization by topological sort.
+                                                        // http://en.wikipedia.org/wiki/Topological_sorting#Algorithms
+                                                        var topologicallySorted = [];
+                                                        
+                                                        // 1. Build the source nodes graph, and find the start nodes set.
+                                                        var sourceNodes = {};
+                                                        for ( pluginName in allPlugins )
+                                                        {
+                                                                var plugin = allPlugins[ pluginName ];
+                                                                sourceNodes[ pluginName ] =
+                                                                {
+                                                                        name : pluginName,
+                                                                        requires : plugin.requires ? plugin.requires.concat( [] ) : [],
+                                                                        requiredBy : 0
+                                                                };
+                                                        }
+
+                                                        var startNodes = CKEDITOR.tools.extend( {}, sourceNodes );
+                                                        for ( pluginName in sourceNodes )
+                                                        {
+                                                                var node = sourceNodes[ pluginName ];
+                                                                for ( var i = 0 ; i < node.requires.length ; i++ )
+                                                                {
+                                                                        var requireName = node.requires[ i ];
+                                                                        delete startNodes[ requireName ];
+                                                                        node.requires[ i ] = sourceNodes[ requireName ];
+                                                                        node.requires[ i ].requiredBy++;
+                                                                }
+                                                        }
+
+                                                        // 2. Perform topological sort from the set of start nodes.
+                                                        var previousStartNodes = startNodes;
+                                                        startNodes = [];
+                                                        for ( pluginName in previousStartNodes )
+                                                                startNodes.push( pluginName );
+                                                        while ( startNodes.length > 0 )
+                                                        {
+                                                                var node = sourceNodes[ startNodes.shift() ];
+                                                                topologicallySorted.unshift( node.name );
+                                                                while ( node.requires.length > 0 )
+                                                                {
+                                                                        var child = node.requires[ 0 ];
+                                                                        node.requires.shift();
+                                                                        child.requiredBy--;
+                                                                        if ( child.requiredBy < 1 )
+                                                                                startNodes.push( child.name );
+                                                                }
+                                                        }
+
+                                                        // 3. Rebuild the allPlugins dictionary from the topologically sorted
+                                                        // order.
+                                                        var temp = {};
+                                                        for ( var i = 0 ; i < topologicallySorted.length ; i++ )
+                                                                temp[ topologicallySorted[ i ] ] = allPlugins[ topologicallySorted[ i ] ];
+                                                        allPlugins = temp;
+
                                                         // Call the "onLoad" function for all plugins.
                                                         for ( pluginName in allPlugins )
                                                         {