primer cambio

node_modules/toposort-class/benchmark/0.3.1/toposort.js

@@ -0,0 +1,128 @@
+!function() {
+    "use strict";
+
+    /**
+     * Topological sort class.
+     * Original by Marcel Klehr, contributed by Gustavo Henke.
+     *
+     * @class
+     * @since   0.1.0
+     * @see     https://github.com/marcelklehr/toposort
+     * @author  Marcel Klehr <mklehr@gmx.net>
+     *
+     * @see     https://github.com/gustavohenke/toposort
+     * @author  Gustavo Henke <gustavo@injoin.com.br>
+     */
+    function Toposort() {
+        var self = this;
+        var edges = [];
+
+        /**
+         * Adds dependency edges.
+         *
+         * @since   0.1.0
+         * @param   {String} item               An dependent name. Must be an string and not empty
+         * @param   {String[]|String} [deps]    An dependency or array of dependencies
+         * @returns {Toposort}                  The Toposort instance
+         */
+        self.add = function( item, deps ) {
+            if( typeof item !== "string" || !item ) {
+                throw new TypeError( "Dependent name must be given as a not empty string" );
+            }
+
+            deps = Array.isArray( deps ) ? deps.slice() : [deps];
+            if( deps.length ) {
+                deps.forEach( function( dep ) {
+                    if( typeof dep !== "string" || !dep ) {
+                        throw new TypeError(
+                            "Dependency name must be given as a not empty string"
+                        );
+                    }
+
+                    edges.push( [item, dep] );
+                } );
+            } else {
+                edges.push( [item] );
+            }
+
+            return self;
+        };
+
+        /**
+         * Runs the toposorting and return an ordered array of strings
+         *
+         * @since   0.1.0
+         * @returns {String[]}  The list of items topologically sorted.
+         */
+        self.sort = function() {
+            var nodes = [];
+            var sorted = [];
+
+            edges.forEach( function( edge ) {
+                edge.forEach( function( n ) {
+                    if( nodes.indexOf( n ) === -1 ) {
+                        nodes.push( n );
+                    }
+                } );
+            } );
+
+            function visit( node, predecessors, i ) {
+                var index, predsCopy;
+                predecessors = predecessors || [];
+
+                if( predecessors.indexOf( node ) > -1 ) {
+                    throw new Error(
+                        "Cyclic dependency found. '" + node + "' is dependent of itself.\n" +
+                        "Dependency Chain: " + predecessors.join( " -> " ) + " => " + node
+                    );
+                }
+
+                index = nodes.indexOf( node );
+                if( index === -1 ) {
+                    return i;
+                }
+
+                nodes.splice( index, 1 );
+                if( predecessors.length === 0 ) {
+                    i--;
+                }
+
+                predsCopy = predecessors.slice();
+                predsCopy.push( node );
+
+                edges.filter( function( e ) {
+                    return e[0] === node;
+                } ).forEach( function( e ) {
+                    i = visit( e[1], predsCopy, i );
+                } );
+
+                sorted.unshift( node );
+                return i;
+            }
+
+            for( var i = 0; i < nodes.length; i++ ) {
+                i = visit( nodes[i], null, i );
+            }
+
+            return sorted;
+        };
+
+    }
+
+    if( typeof module === "object" && module && typeof module.exports === "object" ) {
+        // Expose toposort to CommonJS loaders (aka Node)
+        module.exports = exports.Toposort = Toposort;
+    } else {
+        // Expose toposort to AMD loaders (aka Require.js)
+        if( typeof define === "function" && define.amd ) {
+            define( function() {
+                return Toposort;
+            } );
+        }
+
+        // Expose toposort as a browser global
+        if( typeof window === "object" ) {
+            window.Toposort = Toposort;
+        }
+    }
+}();

node_modules/toposort-class/benchmark/README.md

@@ -0,0 +1,11 @@
+Benchmarks
+==========
+
+Since I'm obsessed with performance, here is a tiny benchmark comparing the performance of the 0.3.1 version and the current version written in ES6
+
+| Description                  | Library         | Op/s       |  %   |
+|------------------------------|-----------------|-----------:|-----:|
+| simple dependency chains     | 0.3.1 version   | 66,722.22  | 8%   |
+|                              | current version | 837,416.60 | 100% |
+| slightly more complex chains | 0.3.1 version   | 24,530.85  | 6%   |
+|                              | current version | 386,620.50 | 100% |

node_modules/toposort-class/benchmark/general.js

@@ -0,0 +1,56 @@
+var Toposort = require( "../index.js" );
+var OldToposort = require( "./0.3.1/toposort.js" );
+
+suite( "simple dependency chains", function() {
+    set( "delay", 0 );
+    set( "mintime", 1750 );
+
+    bench( "0.3.1 version", function() {
+        var t = new OldToposort();
+
+        t.add( "3", "2" )
+            .add( "2", "1" )
+            .add( "6", "5" )
+            .add( "5", ["2", "4"] ).sort();
+    } );
+
+    bench( "current version", function() {
+        var t = new Toposort();
+
+        t.add( "3", "2" )
+            .add( "2", "1" )
+            .add( "6", "5" )
+            .add( "5", ["2", "4"] ).sort();
+    } );
+} );
+
+suite( "slightly more complex chains", function() {
+    set( "delay", 0 );
+    set( "mintime", 1750 );
+
+    bench( "0.3.1 version", function() {
+        var t = new OldToposort();
+
+        t.add( "3", "1" )
+            .add( "2", "3" )
+            .add( "4", ["2", "3"] )
+            .add( "5", ["3", "4"] )
+            .add( "6", ["3", "4", "5"] )
+            .add( "7", "1" )
+            .add( "8", ["1", "2", "3", "4", "5"] )
+            .add( "9", ["8", "6", "7"] ).sort();
+    } );
+
+    bench( "current version", function() {
+        var t = new Toposort();
+
+        t.add( "3", "1" )
+            .add( "2", "3" )
+            .add( "4", ["2", "3"] )
+            .add( "5", ["3", "4"] )
+            .add( "6", ["3", "4", "5"] )
+            .add( "7", "1" )
+            .add( "8", ["1", "2", "3", "4", "5"] )
+            .add( "9", ["8", "6", "7"] ).sort();
+    } );
+} );

node_modules/toposort-class/benchmark/results.csv

@@ -0,0 +1,4 @@
+2015-07-31 22:37:51,"simple dependency chains","0.3.1 version",2295.217390,153142
+2015-07-31 22:37:51,"simple dependency chains","current version",3299.024625,2762658
+2015-07-31 22:37:51,"slightly more complex chains","0.3.1 version",3313.337523,81279
+2015-07-31 22:37:51,"slightly more complex chains","current version",1797.512029,694955