jsmetric 0.1

data/features/cyclometric_complexity/if_else_complexity_counting.feature

@@ -0,0 +1,178 @@
+@ifelse
+Feature: Calculate IF/ELSE complexity for a stand alone Javascript function
+
+  Scenario: No branches
+    Given javascript code as:
+    """
+      function foo() { };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "1"
+
+  Scenario: Just one IF statement
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: 2 sequential IF statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        if (true) {
+          // do something else
+        }        
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: 2 nested IF statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+          if (true) {
+            // do something else
+          }
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: A single IF with Else statement
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        else {
+          // do something else
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: 2 nested IF/Else statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+          if (true) {
+            // do something else
+          }
+          else {
+            // do this
+          }
+        }
+        else {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: An IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+        }
+        else if(true) {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: An IF-ELSE-IF and then ELSE type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        else if(true) {
+          // do this
+        }
+        else {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+
+  Scenario: A nested IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          if (true) {
+          }
+          else if(true) {
+            // do that
+          }
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "4"
+
+  Scenario: Multiple nested IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          if (true) {
+            // do this
+          }
+          else if(true) {
+            // do that
+          }
+        }
+        else if(true) {
+            // do something
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "5"
+
+  Scenario: IF statement implied with ?
+    Given javascript code as:
+    """
+      function foo() {
+        (true)? true : false;
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+
+  Scenario: IF statement nested inside a ternary operator
+    Given javascript code as:
+    """
+      function foo() {
+        (true)? "" : (false) ? true :"" ;
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"

data/features/cyclometric_complexity/loop_complexity_counting.feature

@@ -0,0 +1,81 @@
+@loops
+Feature: Calculate LOOP complexity for a stand alone Javascript function
+
+  Scenario: Single FOR loop
+    Given javascript code as:
+    """
+      function foo() {
+        var i;
+        for(i=1;i<3;i++) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: Single WHILE loop
+    Given javascript code as:
+    """
+      function foo() {
+        while(true) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: Single DO/WHILE  loop
+    Given javascript code as:
+    """
+      function foo() {
+        do { }
+        while (true);
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+    Scenario: Multiple WHILE/DO loops in sequence
+    Given javascript code as:
+    """
+      function foo() {
+        while (true)
+        {
+        // do something
+        }
+
+        do {
+          // something else
+        }
+        while (true);
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+    Scenario: Nested FOR loops
+      Given javascript code as:
+      """
+        function foo() {
+          var i,j;
+          for(i=1;i<3;i++) {
+            for(j=1;j<3;j++) {
+            }
+          }
+        };
+      """
+      When I run the complexity analysis on it
+      Then the complexity is reported as "3"
+
+  Scenario: Nested FOR loops
+    Given javascript code as:
+    """
+      function foo() {
+       while(true) {
+         do {
+
+         }
+         while(true)
+       }
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"

data/features/graphing/draw_basic_graph.feature

@@ -0,0 +1,14 @@
+Feature: Output JSON to describe calls within a class
+
+  Scenario: Empty graph data when there is no JavaScript
+    Given javascript code as:
+      """
+
+      """
+    When I run the graph analysis on it
+    Then the JSON object returned is:
+    """
+    {
+      "graphdata" : {}
+    }
+    """

data/features/reporting/report.feature

@@ -0,0 +1,13 @@
+@reports
+Feature: Generate a report for a given JS file
+
+Scenario: CC and Function name report generated for single sample JS file
+  Given a sample JS file called "foobar"
+  When the CC report target in run on it
+  Then the contents of the report are as follows
+  """
+  Name, CC
+  Klass,3
+  constructor,2
+  Annonymous,2
+  """

data/features/sample_js_files_for_test/foobar.js

@@ -0,0 +1,30 @@
+// A Sample Test function
+function Klass(definition)
+{
+    var prototype = definition;
+
+    if (definition['_extends'] !== undefined)
+    {
+        $.each(definition['_extends'].prototype, function(k, v){
+
+            if (prototype[k] === undefined) {
+                prototype[k] = v;
+            } else {
+                prototype[k+'_super'] = v;
+            }
+        });
+    }
+
+    var constructor = definition['_init'];
+    if (constructor === undefined)
+    {
+        constructor = function()
+        {
+            if (this.prototype('_init_super')) {
+                this._init_super();
+            }
+        }
+    }
+    constructor.prototype = prototype;
+    return constructor
+}

data/features/step_definitions/cyclometric_complexity_steps.rb

@@ -0,0 +1,31 @@
+#TODO: rename this file
+
+Given /^javascript code as:$/ do |string|
+  @code = string
+end
+
+When /^I run the complexity analysis on it$/ do
+  @analyser = ComplexityAnalyser.new
+  @analyser.parse(@code)
+end
+
+Then /^the number of functions is reported as "([^"]*)"$/ do |num_funcs|
+  @analyser.functions.count.should eql num_funcs.to_i
+end
+
+Then /^the complexity is reported as "([^"]*)"$/ do |complexity|
+  @analyser.functions.first[:complexity].should eql complexity.to_i
+end
+
+And /^the function name is "([^"]*)"$/ do |func_name|
+  @analyser.functions.first[:name].should eql func_name
+end
+
+And /^the function names are:$/ do |table|  
+  table.hashes.each do |function|
+    match = @analyser.functions.find {|func| func[:name].eql?(function["Name"])}
+    match.should_not be_nil, "Could not find function with name '#{function["Name"]}' in #{@analyser.functions}"
+  end
+
+end
+

data/features/step_definitions/graph_steps.rb

@@ -0,0 +1,10 @@
+#specific to graph analysis
+
+When /^I run the graph analysis on it$/ do
+  @analyser = GraphAnalyser.new
+  @analyser.parse(@code)
+end
+
+Then /^the JSON object returned is:$/ do |json|
+  JSON.parse(@analyser.json).should eql JSON.parse(json)
+end

data/features/step_definitions/reporting_steps.rb

@@ -0,0 +1,14 @@
+Given /^a sample JS file called "([^"]*)"$/ do |filename|
+  @filename = filename
+end
+
+When /^the CC report target in run on it$/ do
+  path = File.join(File.dirname(__FILE__),'..', "sample_js_files_for_test", @filename + ".js")
+  contents = File.open(path, 'r') { |f| f.read }  
+  @results = CCReport.generate_for contents
+end
+
+Then /^the contents of the report are as follows$/ do |expected_report|
+  @results.should == expected_report
+end
+

data/features/support/env.rb

@@ -0,0 +1 @@
+require(File.join(File.dirname(__FILE__),'..' ,'..','boot'))

data/jsgraphlib/Curry-1.0.1.js

@@ -0,0 +1,29 @@
+/**
+ * Curry - Function currying
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 10/4/2008
+ *
+ * @author Ariel Flesler
+ * @version 1.0.1
+ */
+
+function curry( fn ){
+	return function(){
+		var args = curry.args(arguments),
+			master = arguments.callee,
+			self = this;
+
+		return args.length >= fn.length ? fn.apply(self,args) :	function(){
+			return master.apply( self, args.concat(curry.args(arguments)) );
+		};
+	};
+};
+
+curry.args = function( args ){
+	return Array.prototype.slice.call(args);
+};
+
+Function.prototype.curry = function(){
+	return curry(this);
+};

data/jsgraphlib/dracula_algorithms.js

@@ -0,0 +1,599 @@
+/*
+ * Various algorithms and data structures, licensed under the MIT-license.
+ * (c) 2010 by Johann Philipp Strathausen <strathausen@gmail.com>
+ * http://strathausen.eu
+ *
+ */
+
+
+
+/*
+        Bellman-Ford
+    
+    Path-finding algorithm, finds the shortest paths from one node to all nodes.
+    
+    
+        Complexity
+        
+    O( |E| · |V| ), where E = edges and V = vertices (nodes)
+    
+    
+        Constraints
+    
+    Can run on graphs with negative edge weights as long as they do not have
+    any negative weight cycles.
+    
+ */
+function bellman_ford(g, source) {
+
+    /* STEP 1: initialisation */
+    for(var n in g.nodes)
+        g.nodes[n].distance = Infinity;
+        /* predecessors are implicitly null */
+    source.distance = 0;
+    
+    step("Initially, all distances are infinite and all predecessors are null.");
+    
+    /* STEP 2: relax each edge (this is at the heart of Bellman-Ford) */
+    /* repeat this for the number of nodes minus one */
+    for(var i = 1; i < g.nodes.length; i++)
+        /* for each edge */
+        for(var e in g.edges) {
+            var edge = g.edges[e];
+            if(edge.source.distance + edge.weight < edge.target.distance) {
+                step("Relax edge between " + edge.source.id + " and " + edge.target.id + ".");
+                edge.target.distance = edge.source.distance + edge.weight;
+                edge.target.predecessor = edge.source;
+            }
+	    //Added by Jake Stothard (Needs to be tested)
+	    if(!edge.style.directed) {
+		if(edge.target.distance + edge.weight < edge.source.distance) {
+                    g.snapShot("Relax edge between "+edge.target.id+" and "+edge.source.id+".");
+                    edge.source.distance = edge.target.distance + edge.weight;
+                    edge.source.predecessor = edge.target;
+		}
+	    }
+        }
+    step("Ready.");
+    
+    /* STEP 3: TODO Check for negative cycles */
+    /* For now we assume here that the graph does not contain any negative
+       weights cycles. (this is left as an excercise to the reader[tm]) */
+}
+
+
+
+/*
+   Path-finding algorithm Dijkstra
+   
+   - worst-case running time is O((|E| + |V|) · log |V| ) thus better than
+     Bellman-Ford for sparse graphs (with less edges), but cannot handle
+     negative edge weights
+ */
+function dijkstra(g, source) {
+
+    /* initially, all distances are infinite and all predecessors are null */
+    for(var n in g.nodes)
+        g.nodes[n].distance = Infinity;
+        /* predecessors are implicitly null */
+
+    g.snapShot("Initially, all distances are infinite and all predecessors are null.");
+
+    source.distance = 0;
+    /* set of unoptimized nodes, sorted by their distance (but a Fibonacci heap
+       would be better) */
+    var q = new BinaryMinHeap(g.nodes, "distance");
+
+    /* pointer to the node in focus */
+    var node;
+
+    /* get the node with the smallest distance
+       as long as we have unoptimized nodes. q.min() can have O(log n). */
+    while(q.min() != undefined) {
+        /* remove the latest */
+        node = q.extractMin();
+        node.optimized = true;
+
+        /* no nodes accessible from this one, should not happen */
+        if(node.distance == Infinity)
+            throw "Orphaned node!";
+
+        /* for each neighbour of node */
+        for(e in node.edges) {
+	    var other = (node == node.edges[e].target) ? node.edges[e].source : node.edges[e].target;
+		
+            if(other.optimized)
+                continue;
+
+            /* look for an alternative route */
+            var alt = node.distance + node.edges[e].weight;
+            
+            /* update distance and route if a better one has been found */
+            if (alt < other.distance) {
+            
+                /* update distance of neighbour */
+                other.distance = alt;
+
+                /* update priority queue */
+                q.heapify();
+
+                /* update path */
+                other.predecessor = node;
+                g.snapShot("Enhancing node.")
+            }
+        }
+    }
+}
+
+
+/* All-Pairs-Shortest-Paths */
+/* Runs at worst in O(|V|³) and at best in Omega(|V|³) :-)
+   complexity Sigma(|V|²) */
+/* This implementation is not yet ready for general use, but works with the
+   Dracula graph library. */
+function floyd_warshall(g, source) {
+
+    /* Step 1: initialising empty path matrix (second dimension is implicit) */
+    var path = [];
+    var next = [];
+    var n = g.nodes.length;
+
+    /* construct path matrix, initialize with Infinity */
+    for(j in g.nodes) {
+        path[j] = [];
+        next[j] = [];
+        for(i in g.nodes)
+            path[j][i] = j == i ? 0 : Infinity;
+    }   
+    
+    /* initialize path with edge weights */
+    for(e in g.edges)
+        path[g.edges[e].source.id][g.edges[e].target.id] = g.edges[e].weight;
+    
+    /* Note: Usually, the initialisation is done by getting the edge weights
+       from a node matrix representation of the graph, not by iterating through
+       a list of edges as done here. */
+    
+    /* Step 2: find best distances (the heart of Floyd-Warshall) */
+    for(k in g.nodes){
+        for(i in g.nodes) {
+            for(j in g.nodes)
+                if(path[i][j] > path[i][k] + path[k][j]) {
+                    path[i][j] = path[i][k] + path[k][j];
+                    /* Step 2.b: remember the path */
+                    next[i][j] = k;
+                }
+        }
+    }
+
+    /* Step 3: Path reconstruction, get shortest path */
+    function getPath(i, j) {
+        if(path[i][j] == Infinity)
+            throw "There is no path.";
+        var intermediate = next[i][j];
+        if(intermediate == undefined)
+            return null;
+        else
+            return getPath(i, intermediate)
+                .concat([intermediate])
+                .concat(getPath(intermediate, j));
+    }
+
+    /* TODO use the knowledge, e.g. mark path in graph */
+}
+
+/*
+        Ford-Fulkerson
+    
+    Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
+    graph from source to sink.
+    
+    
+        Complexity
+
+    O(E * max(f)), max(f) being the maximum flow
+    
+    
+        Description
+
+    As long as there is an open path through the residual graph, send the
+    minimum of the residual capacities on the path.
+    
+    
+        Constraints
+    
+    The algorithm works only if all weights are integers. Otherwise it is
+    possible that the Ford–Fulkerson algorithm will not converge to the maximum
+    value.
+    
+    
+        Input
+    
+    g - Graph object
+    s - Source ID
+    t - Target (sink) ID
+    
+    
+        Output
+    
+    Maximum flow from Source s to Target t
+
+ */
+/*
+        Edmonds-Karp
+    
+    Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed
+    graph from source to sink. An implementation of the Ford-Fulkerson
+    algorithm.
+    
+    
+        Complexity
+    
+    O(|V|*|E|²)
+    
+    
+        Input
+        
+    g - Graph object (with node and edge lists, capacity is a property of edge)
+    s - source ID
+    t - sink ID
+    
+ */
+function edmonds_karp(g, s, t) {
+
+}
+
+/*
+   A simple binary min-heap serving as a priority queue
+   - takes an array as the input, with elements having a key property
+   - elements will look like this:
+        {
+            key: "... key property ...", 
+            value: "... element content ..."
+        }
+    - provides insert(), min(), extractMin() and heapify()
+    - example usage (e.g. via the Firebug or Chromium console):
+        var x = {foo: 20, hui: "bla"};
+        var a = new BinaryMinHeap([x,{foo:3},{foo:10},{foo:20},{foo:30},{foo:6},{foo:1},{foo:3}],"foo");
+        console.log(a.extractMin());
+        console.log(a.extractMin());
+        x.foo = 0; // update key
+        a.heapify(); // call this always after having a key updated
+        console.log(a.extractMin());
+        console.log(a.extractMin());
+    - can also be used on a simple array, like [9,7,8,5]
+ */
+function BinaryMinHeap(array, key) {
+    
+    /* Binary tree stored in an array, no need for a complicated data structure */
+    var tree = [];
+    
+    var key = key || 'key';
+    
+    /* Calculate the index of the parent or a child */
+    var parent = function(index) { return Math.floor((index - 1)/2); };
+    var right = function(index) { return 2 * index + 2; };
+    var left = function(index) { return 2 * index + 1; };
+
+    /* Helper function to swap elements with their parent 
+       as long as the parent is bigger */
+    function bubble_up(i) {
+        var p = parent(i);
+        while((p >= 0) && (tree[i][key] < tree[p][key])) {
+            /* swap with parent */
+            tree[i] = tree.splice(p, 1, tree[i])[0];
+            /* go up one level */
+            i = p;
+            p = parent(i);
+        }
+    }
+
+    /* Helper function to swap elements with the smaller of their children
+       as long as there is one */
+    function bubble_down(i) {
+        var l = left(i);
+        var r = right(i);
+        
+        /* as long as there are smaller children */
+        while(tree[l] && (tree[i][key] > tree[l][key]) || tree[r] && (tree[i][key] > tree[r][key])) {
+            
+            /* find smaller child */
+            var child = tree[l] ? tree[r] ? tree[l][key] > tree[r][key] ? r : l : l : l;
+            
+            /* swap with smaller child with current element */
+            tree[i] = tree.splice(child, 1, tree[i])[0];
+            
+            /* go up one level */
+            i = child;
+            l = left(i);
+            r = right(i);
+        }
+    }
+    
+    /* Insert a new element with respect to the heap property
+       1. Insert the element at the end
+       2. Bubble it up until it is smaller than its parent */
+    this.insert = function(element) {
+    
+        /* make sure there's a key property */
+        (element[key] == undefined) && (element = {key:element});
+        
+        /* insert element at the end */
+        tree.push(element);
+
+        /* bubble up the element */
+        bubble_up(tree.length - 1);
+    }
+    
+    /* Only show us the minimum */
+    this.min = function() {
+        return tree.length == 1 ? undefined : tree[0];
+    }
+    
+    /* Return and remove the minimum
+       1. Take the root as the minimum that we are looking for
+       2. Move the last element to the root (thereby deleting the root) 
+       3. Compare the new root with both of its children, swap it with the
+          smaller child and then check again from there (bubble down)
+    */
+    this.extractMin = function() {
+        var result = this.min();
+        
+        /* move the last element to the root or empty the tree completely */
+        /* bubble down the new root if necessary */
+        (tree.length == 1) && (tree = []) || (tree[0] = tree.pop()) && bubble_down(0);
+        
+        return result;        
+    }
+    
+    /* currently unused, TODO implement */
+    this.changeKey = function(index, key) {
+        throw "function not implemented";
+    }
+
+    this.heapify = function() {
+        for(var start = Math.floor((tree.length - 2) / 2); start >= 0; start--) {
+            bubble_down(start);
+        }
+    }
+    
+    /* insert the input elements one by one only when we don't have a key property (TODO can be done more elegant) */
+    for(i in (array || []))
+        this.insert(array[i]);
+}
+
+
+
+/*
+    Quick Sort:
+        1. Select some random value from the array, the median.
+        2. Divide the array in three smaller arrays according to the elements
+           being less, equal or greater than the median.
+        3. Recursively sort the array containg the elements less than the
+           median and the one containing elements greater than the median.
+        4. Concatenate the three arrays (less, equal and greater).
+        5. One or no element is always sorted.
+    TODO: This could be implemented more efficiently by using only one array object and several pointers.
+*/
+function quickSort(arr) {
+    /* recursion anchor: one element is always sorted */
+    if(arr.length <= 1) return arr;
+    /* randomly selecting some value */
+    var median = arr[Math.floor(Math.random() * arr.length)];
+    var arr1 = [], arr2 = [], arr3 = [];
+    for(var i in arr) {
+        arr[i] < median && arr1.push(arr[i]);
+        arr[i] == median && arr2.push(arr[i]);
+        arr[i] > median && arr3.push(arr[i]);
+    }
+    /* recursive sorting and assembling final result */
+    return quickSort(arr1).concat(arr2).concat(quickSort(arr3));
+}
+
+/*
+    Selection Sort:
+        1. Select the minimum and remove it from the array
+        2. Sort the rest recursively
+        3. Return the minimum plus the sorted rest
+        4. An array with only one element is already sorted
+*/
+function selectionSort(arr) {
+    /* recursion anchor: one element is always sorted */
+    if(arr.length == 1) return arr;
+    var minimum = Infinity;
+    var index;
+    for(var i in arr) {
+        if(arr[i] < minimum) {
+            minimum = arr[i];
+            index = i; /* remember the minimum index for later removal */
+        }
+    }
+    /* remove the minimum */
+    arr.splice(index, 1);
+    /* assemble result and sort recursively (could be easily done iteratively as well)*/
+    return [minimum].concat(selectionSort(arr));
+}
+
+/*
+    Merge Sort:
+        1. Cut the array in half
+        2. Sort each of them recursively
+        3. Merge the two sorted arrays
+        4. An array with only one element is considered sorted
+
+*/
+function mergeSort(arr) {
+    /* merges two sorted arrays into one sorted array */
+    function merge(a, b) {
+        /* result set */
+        var c = [];
+        /* as long as there are elements in the arrays to be merged */
+        while(a.length > 0 || b.length > 0){
+            /* are there elements to be merged, if yes, compare them and merge */
+            var n = a.length > 0 && b.length > 0 ? a[0] < b[0] ? a.shift() : b.shift() : b.length > 0 ? b.shift() : a.length > 0 ? a.shift() : null;
+            /* always push the smaller one onto the result set */
+            n != null && c.push(n);
+        }
+        return c;
+    }
+    /* this mergeSort implementation cuts the array in half, wich should be fine with randomized arrays, but introduces the risk of a worst-case scenario */
+    median = Math.floor(arr.length / 2);
+    var part1 = arr.slice(0, median); /* for some reason it doesn't work if inserted directly in the return statement (tried so with firefox) */
+    var part2 = arr.slice(median - arr.length);
+    return arr.length <= 1 ? arr : merge(
+        mergeSort(part1), /* first half */
+        mergeSort(part2) /* second half */
+    );
+}
+
+/* Balanced Red-Black-Tree */
+function RedBlackTree(arr) {
+    
+}
+
+function BTree(arr) {
+    
+}
+
+function NaryTree(n, arr) {
+    
+}
+
+/**
+ * Knuth-Morris-Pratt string matching algorithm - finds a pattern in a text.
+ * FIXME: Doesn't work correctly yet.
+ */
+function kmp(p, t) {
+
+    /**
+     * PREFIX, OVERLAP or FALIURE function for KMP. Computes how many iterations
+     * the algorithm can skip after a mismatch.
+     *
+     * @input p - pattern (string)
+     * @result array of skippable iterations
+     */
+    function prefix(p) {
+        /* pi contains the computed skip marks */
+        var pi = [0], k = 0;
+        for(q = 1; q < p.length; q++) {
+            while(k > 0 && (p.charAt(k) != p.charAt(q)))
+                k = pi[k-1];
+            
+            (p.charAt(k) == p.charAt(q)) && k++;
+            
+            pi[q] = k;
+        }
+        return pi;
+    }
+    
+    /* The actual KMP algorithm starts here. */
+    
+    var pi = prefix(p), q = 0, result = [];
+    
+    for(var i = 0; i < t.length; i++) {
+        /* jump forward as long as the character doesn't match */
+        while((q > 0) && (p.charAt(q) != t.charAt(i)))
+            q = pi[q];
+        
+        (p.charAt(q) == t.charAt(i)) && q++;
+        
+        (q == p.length) && result.push(i - p.length) && (q = pi[q]);
+    }
+    
+    return result;
+}
+
+/* step for algorithm visualisation */
+function step(comment, funct) {
+    //wait for input
+    //display comment (before or after waiting)
+//    next.wait();
+    /* execute callback function */
+    funct();
+}
+
+/**
+ * Curry - Function currying
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 10/4/2008
+ *
+ * @author Ariel Flesler
+ * @version 1.0.1
+ */
+function curry( fn ){
+	return function(){
+		var args = curry.args(arguments),
+			master = arguments.callee,
+			self = this;
+
+		return args.length >= fn.length ? fn.apply(self,args) :	function(){
+			return master.apply( self, args.concat(curry.args(arguments)) );
+		};
+	};
+};
+
+curry.args = function( args ){
+	return Array.prototype.slice.call(args);
+};
+
+Function.prototype.curry = function(){
+	return curry(this);
+};
+
+/**
+ * Topological Sort
+ *
+ * Sort a directed graph based on incoming edges
+ *
+ * Coded by Jake Stothard
+ */
+function topological_sort(g) {
+    //Mark nodes as "deleted" instead of actually deleting them
+    //That way we don't have to copy g
+
+    for(i in g.nodes)
+	g.nodes[i].deleted = false;
+    
+    var ret = topological_sort_helper(g);
+
+    //Cleanup: Remove the deleted property
+    for(i in g.nodes)
+	delete g.nodes[i].deleted
+
+    return ret;
+}
+function topological_sort_helper(g) {
+    //Find node with no incoming edges
+    var node;
+    for(i in g.nodes) {
+	if(g.nodes[i].deleted)
+	    continue; //Bad style, meh
+	
+	var incoming = false;
+	for(j in g.nodes[i].edges) {
+	    if(g.nodes[i].edges[j].target == g.nodes[i]
+	      && g.nodes[i].edges[j].source.deleted == false) {
+		incoming = true;
+		break;
+	    }
+	}
+	if(!incoming) {
+	    node = g.nodes[i];
+	    break;
+	}
+    }
+
+    // Either unsortable or done. Either way, GTFO
+    if(node == undefined)
+	return [];
+
+    //"Delete" node from g
+    node.deleted = true;
+    
+    var tail = topological_sort_helper(g);
+
+    tail.unshift(node);
+
+    return tail;
+}