Initial commit

node_modules/graphlib-dot/lib/build-graph.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _ = require("./lodash"),
+    Graph = require("./graphlib").Graph;
+
+module.exports = buildGraph;
+
+function buildGraph(parseTree) {
+  var isDirected = parseTree.type !== "graph",
+      isMultigraph = !parseTree.strict,
+      defaultStack = [{ node: {}, edge: {} }],
+      id = parseTree.id,
+      g = new Graph({ directed: isDirected, multigraph: isMultigraph, compound: true });
+      g.setGraph(id === null ? {} : {id: id});
+  _.each(parseTree.stmts, function(stmt) { handleStmt(g, stmt, defaultStack); });
+  return g;
+}
+
+function handleStmt(g, stmt, defaultStack, sg) {
+  switch(stmt.type) {
+    case "node": handleNodeStmt(g, stmt, defaultStack, sg); break;
+    case "edge": handleEdgeStmt(g, stmt, defaultStack, sg); break;
+    case "subgraph": handleSubgraphStmt(g, stmt, defaultStack, sg); break;
+    case "attr": handleAttrStmt(g, stmt, defaultStack); break;
+    case "inlineAttr": handleInlineAttrsStmt(g, stmt, defaultStack, sg); break;
+  }
+}
+
+function handleNodeStmt(g, stmt, defaultStack, sg) {
+  var v = stmt.id,
+      attrs = stmt.attrs;
+  maybeCreateNode(g, v, defaultStack, sg);
+  _.merge(g.node(v), attrs);
+}
+
+function handleEdgeStmt(g, stmt, defaultStack, sg) {
+  var attrs = stmt.attrs,
+      prev, curr;
+  _.each(stmt.elems, function(elem) {
+    handleStmt(g, elem, defaultStack, sg);
+
+    switch(elem.type) {
+      case "node": curr = [elem.id]; break;
+      case "subgraph": curr = collectNodeIds(elem); break;
+    }
+
+    _.each(prev, function(v) {
+      _.each(curr, function(w) {
+        var name;
+        if (g.hasEdge(v, w) && g.isMultigraph()) {
+          name = _.uniqueId("edge");
+        }
+        if (!g.hasEdge(v, w, name)) {
+          g.setEdge(v, w, _.clone(_.last(defaultStack).edge), name);
+        }
+        _.merge(g.edge(v, w, name), attrs);
+      });
+    });
+
+    prev = curr;
+  });
+}
+
+function handleSubgraphStmt(g, stmt, defaultStack, sg) {
+  var id = stmt.id;
+  if (id === undefined) {
+    id = generateSubgraphId(g);
+  }
+
+  defaultStack.push(_.clone(_.last(defaultStack)));
+
+  maybeCreateNode(g, id, defaultStack, sg);
+
+  _.each(stmt.stmts, function(s) {
+    handleStmt(g, s, defaultStack, id);
+  });
+
+  // If there are no statements remove the subgraph
+  if (!g.children(id).length) {
+    g.removeNode(id);
+  }
+
+  defaultStack.pop();
+}
+
+function handleAttrStmt(g, stmt, defaultStack) {
+  _.merge(_.last(defaultStack)[stmt.attrType], stmt.attrs);
+}
+
+function handleInlineAttrsStmt(g, stmt, defaultStack, sg) {
+  _.merge(sg ? g.node(sg) : g.graph(), stmt.attrs);
+}
+
+function generateSubgraphId(g) {
+  var id;
+  do {
+    id = _.uniqueId("sg");
+  } while (g.hasNode(id));
+  return id;
+}
+
+function maybeCreateNode(g, v, defaultStack, sg) {
+  if (!g.hasNode(v)) {
+    g.setNode(v, _.clone(_.last(defaultStack).node));
+    g.setParent(v, sg);
+  }
+}
+
+// Collect all nodes involved in a subgraph statement
+function collectNodeIds(stmt) {
+  var ids = {},
+      stack = [],
+      curr;
+
+  var push = stack.push.bind(stack);
+
+  push(stmt);
+  while(stack.length) {
+    curr = stack.pop();
+    switch(curr.type) {
+      case "node": ids[curr.id] = true; break;
+      case "edge": _.each(curr.elems, push); break;
+      case "subgraph": _.each(curr.stmts, push); break;
+    }
+  }
+
+  return _.keys(ids);
+}
+

node_modules/graphlib-dot/lib/graphlib.js

@@ -0,0 +1,15 @@
+/* global window */
+
+var graphlib;
+
+if (require) {
+  try {
+    graphlib = require("graphlib");
+  } catch (e) {}
+}
+
+if (!graphlib) {
+  graphlib = window.graphlib;
+}
+
+module.exports = graphlib;

node_modules/graphlib-dot/lib/index.js

@@ -0,0 +1,9 @@
+var read = require("./read-one"),
+    readMany = require("./read-many"),
+    write = require("./write-one");
+
+module.exports = {
+  read: read,
+  readMany: readMany,
+  write: write
+};

node_modules/graphlib-dot/lib/lodash.js

@@ -0,0 +1,15 @@
+/* global window */
+
+var lodash;
+
+if (require) {
+  try {
+    lodash = require("lodash");
+  } catch (e) {}
+}
+
+if (!lodash) {
+  lodash = window._;
+}
+
+module.exports = lodash;

node_modules/graphlib-dot/lib/read-many.js

@@ -0,0 +1,8 @@
+var _ = require("./lodash"),
+    grammar = require("./dot-grammar"),
+    buildGraph = require("./build-graph");
+
+module.exports = function readMany(str) {
+  var parseTree = grammar.parse(str);
+  return _.map(parseTree, buildGraph);
+};

node_modules/graphlib-dot/lib/read-one.js

@@ -0,0 +1,8 @@
+var grammar = require("./dot-grammar"),
+    buildGraph = require("./build-graph");
+
+module.exports = function readOne(str) {
+  var parseTree = grammar.parse(str, { startRule: "graphStmt" });
+  return buildGraph(parseTree);
+};
+

node_modules/graphlib-dot/lib/version.js

@@ -0,0 +1 @@
+module.exports = '0.6.2';

node_modules/graphlib-dot/lib/write-one.js

@@ -0,0 +1,127 @@
+var _ = require("./lodash");
+
+module.exports = writeOne;
+
+var UNESCAPED_ID_PATTERN = /^[a-zA-Z\200-\377_][a-zA-Z\200-\377_0-9]*$/;
+
+function writeOne(g) {
+  var ec = g.isDirected() ? "->" : "--",
+      writer = new Writer();
+
+  if (!g.isMultigraph()) {
+    writer.write("strict ");
+  }
+
+  writer.writeLine((g.isDirected() ? "digraph" : "graph") + " {");
+  writer.indent();
+
+  var graphAttrs = g.graph();
+  if (_.isObject(graphAttrs)) {
+    _.each(graphAttrs, function(v, k) {
+      writer.writeLine(id(k) + "=" + id(v) + ";");
+    });
+  }
+
+  writeSubgraph(g, undefined, writer);
+
+  g.edges().forEach(function(edge) {
+    writeEdge(g, edge, ec, writer);
+  });
+
+  writer.unindent();
+  writer.writeLine("}");
+
+  return writer.toString();
+}
+
+function writeSubgraph(g, v, writer) {
+  var children = g.isCompound() ? g.children(v) : g.nodes();
+  _.each(children, function(w) {
+    if (!g.isCompound() || !g.children(w).length) {
+      writeNode(g, w, writer);
+    } else {
+      writer.writeLine("subgraph " + id(w) + " {");
+      writer.indent();
+
+      if (_.isObject(g.node(w))) {
+        _.map(g.node(w), function(val, key) {
+          writer.writeLine(id(key) + "=" + id(val) + ";");
+        });
+      }
+
+      writeSubgraph(g, w, writer);
+      writer.unindent();
+      writer.writeLine("}");
+    }
+  });
+}
+
+function writeNode(g, v, writer) {
+  writer.write(id(v));
+  writeAttrs(g.node(v), writer);
+  writer.writeLine();
+}
+
+function writeEdge(g, edge, ec, writer) {
+  var v = edge.v,
+      w = edge.w,
+      attrs = g.edge(edge);
+
+  writer.write(id(v) + " " + ec + " " + id(w));
+  writeAttrs(attrs, writer);
+  writer.writeLine();
+}
+
+function writeAttrs(attrs, writer) {
+  if (_.isObject(attrs)) {
+    var attrStrs = _.map(attrs, function(val, key) {
+      return id(key) + "=" + id(val);
+    });
+    if (attrStrs.length) {
+      writer.write(" [" + attrStrs.join(",") + "]");
+    }
+  }
+}
+
+function id(obj) {
+  if (typeof obj === "number" || obj.toString().match(UNESCAPED_ID_PATTERN)) {
+    return obj;
+  }
+
+  return "\"" + obj.toString().replace(/"/g, "\\\"") + "\"";
+}
+
+// Helper object for making a pretty printer
+function Writer() {
+  this._indent = "";
+  this._content = "";
+  this._shouldIndent = true;
+}
+
+Writer.prototype.INDENT = "  ";
+
+Writer.prototype.indent = function() {
+  this._indent += this.INDENT;
+};
+
+Writer.prototype.unindent = function() {
+  this._indent = this._indent.slice(this.INDENT.length);
+};
+
+Writer.prototype.writeLine = function(line) {
+  this.write((line || "") + "\n");
+  this._shouldIndent = true;
+};
+
+Writer.prototype.write = function(str) {
+  if (this._shouldIndent) {
+    this._shouldIndent = false;
+    this._content += this._indent;
+  }
+  this._content += str;
+};
+
+Writer.prototype.toString = function() {
+  return this._content;
+};
+