@davidsouther/agathon 0.0.0-stage → 0.0.0

package/src/tsabre/parse.ts

@@ -0,0 +1,634 @@
+import { CircleGeometry, type GeometryParams, parseGeometry } from "../geometry.ts";
+import type {
+  EdgeConfig,
+  GraphConfig,
+  LayoutEdge,
+  LayoutGraph,
+  LayoutNode,
+  NodeConfig,
+} from "../layout/types.ts";
+import { type AttributeSet, ElementDiffPresence, type Node } from "../types.ts";
+
+import { TsabreGraph } from "./graph.ts";
+
+/**
+ * Parse a dot digraph block. The subset of DOT we support is LR(1), so it's a
+ * pretty simple recursive descent parser.
+ */
+export function parse(text: string): [LayoutGraph, Array<{}>] {
+  const g = new TsabreGraph<LayoutNode, LayoutEdge>();
+
+  const t = tokenizer(text);
+  const d = Digraph.from(t);
+  d.fill(g);
+
+  return [g, t.errors];
+}
+
+class Digraph {
+  private readonly statements: StatementList;
+  private constructor(statements: StatementList) {
+    this.statements = statements;
+  }
+
+  fill(g: LayoutGraph) {
+    this.statements.fill(g);
+  }
+
+  static from(this: { name: string }, tokens: Tokenizer): Digraph {
+    let token = tokens.peek();
+    if (token.type !== TokenType.Digraph) {
+      tokens.parseError(Digraph.name, "digraph", token);
+    } else {
+      tokens.next();
+    }
+
+    const statements = StatementList.from(tokens);
+
+    token = tokens.peek();
+    if (token.type !== TokenType.End) {
+      tokens.parseError(Digraph.name, "End", token);
+    }
+    return new Digraph(statements);
+  }
+}
+
+class StatementList {
+  private readonly statements: Array<EdgeStatement | NodeStatement>;
+  private readonly attributes: AttributeList;
+  private constructor(statements: Array<EdgeStatement | NodeStatement>, attributes: AttributeList) {
+    this.statements = statements;
+    this.attributes = attributes;
+  }
+
+  fill(g: LayoutGraph, parent?: Node) {
+    for (const statement of this.statements) {
+      statement.fill(g);
+      if (parent && statement instanceof NodeStatement) {
+        statement.setParent(g, parent);
+      }
+    }
+    (
+      g as {
+        // Reopen for a quick assignment here.
+        layout?: Partial<GraphConfig>;
+      }
+    ).layout = this.attributes.graphAttributes;
+    this.attributes.fill(g);
+  }
+
+  // tslint:disable-next-line:enforce-name-casing
+  static Empty() {
+    return new StatementList([], AttributeList.Empty());
+  }
+
+  static from(this: { name: string }, tokens: Tokenizer) {
+    const open = tokens.peek();
+    if (open.type !== TokenType.OpenBlock) {
+      tokens.parseError(StatementList.name, "{", open);
+    } else {
+      tokens.next();
+    }
+    let attributes = AttributeList.Empty();
+    const statements: Array<EdgeStatement | NodeStatement> = [];
+
+    while (tokens.hasNext) {
+      const token = tokens.peek();
+      let statement: EdgeStatement | NodeStatement | undefined;
+      switch (token.type) {
+        case TokenType.OpenAttr:
+          attributes = AttributeList.from(tokens);
+          break;
+        case TokenType.ID:
+          statement = Statement.from(tokens);
+          if (statement) statements.push(statement);
+          break;
+        case TokenType.CloseBlock:
+          tokens.next();
+          return new StatementList(statements, attributes);
+        case TokenType.End:
+          tokens.parseError(StatementList.name, "[ } ID", token);
+          return new StatementList(statements, attributes);
+        default:
+          tokens.next();
+          tokens.parseError(StatementList.name, "[ } ID", token);
+      }
+    }
+    tokens.parseError(StatementList.name, "}", open);
+    if (statements.length > 0) {
+      return new StatementList(statements, attributes);
+    } else {
+      return StatementList.Empty();
+    }
+  }
+}
+
+// tslint:disable-next-line:class-as-namespace keeping static to fit the others.
+class Statement {
+  static from(this: { name: string }, tokens: Tokenizer) {
+    const id = tokens.next();
+    if (id.type !== TokenType.ID) {
+      tokens.parseError(Statement.name, "id", id);
+      return undefined;
+    }
+    const token = tokens.peek();
+    switch (token.type) {
+      case TokenType.Edge:
+        tokens.next();
+        return EdgeStatement.from(tokens, id as Token & { type: typeof TokenType.ID });
+      case TokenType.OpenAttr:
+      case TokenType.OpenBlock:
+      case TokenType.CloseBlock:
+      case TokenType.Semi:
+      case TokenType.End:
+        return NodeStatement.from(tokens, id as Token & { type: typeof TokenType.ID });
+      default:
+        // Advance past the bad token
+        tokens.next();
+        tokens.parseError(Statement.name, "-> [ { ;", token);
+    }
+    return undefined;
+  }
+}
+
+class EdgeStatement {
+  private readonly edge: LayoutEdge;
+
+  private readonly attributes: AttributeList;
+  private constructor(
+    s: Token & { type: typeof TokenType.ID },
+    t: Token & { type: typeof TokenType.ID },
+    n: (Token & { type: typeof TokenType.ID }) | undefined,
+    attributes: AttributeList,
+  ) {
+    this.attributes = attributes;
+    this.edge = {
+      source: s.value,
+      target: t.value,
+      presence: attributes.presence(),
+      layout: this.attributes.edgeAttributes,
+    };
+    if (n !== undefined) {
+      this.edge.name = n.value;
+    }
+  }
+
+  fill(g: LayoutGraph) {
+    const source = this.edge.source;
+    const target = this.edge.target;
+    if (!g.hasNode(source)) g.setNode(source, { id: source });
+    if (!g.hasNode(target)) g.setNode(target, { id: target });
+    g.setEdge(this.edge, this.edge);
+    this.attributes.fill(this.edge);
+  }
+
+  static from(
+    this: { name: string },
+    tokens: Tokenizer,
+    id: Token & {
+      type: typeof TokenType.ID;
+    },
+  ) {
+    const id2 = tokens.next();
+    if (id2.type !== TokenType.ID) {
+      tokens.parseError(EdgeStatement.name, "ID", id2);
+    }
+
+    let multi: (Token & { type: typeof TokenType.ID }) | undefined;
+    let token = tokens.peek();
+
+    if (token.type === TokenType.ID) {
+      multi = token as Token & { type: typeof TokenType.ID };
+      tokens.next();
+      token = tokens.peek();
+    }
+
+    let attributes = AttributeList.Empty();
+    if (token.type === TokenType.OpenAttr) {
+      attributes = AttributeList.from(tokens);
+      token = tokens.peek();
+    }
+
+    if (token.type === TokenType.Semi) {
+      tokens.next();
+      return new EdgeStatement(id, id2 as Token & { type: typeof TokenType.ID }, multi, attributes);
+    } else if (token.type === TokenType.CloseBlock) {
+      return new EdgeStatement(id, id2 as Token & { type: typeof TokenType.ID }, multi, attributes);
+    } else {
+      tokens.parseError(EdgeStatement.name, "; or }", token);
+    }
+
+    if (id2.type === TokenType.ID) {
+      return new EdgeStatement(id, id2 as Token & { type: typeof TokenType.ID }, multi, attributes);
+    } else {
+      tokens.parseError(EdgeStatement.name, "ID", id);
+    }
+
+    return undefined;
+  }
+}
+
+class NodeStatement {
+  private readonly node: LayoutNode;
+  private readonly attributeList: AttributeList;
+  private readonly statementList: StatementList;
+  private constructor(
+    id: Token & { type: typeof TokenType.ID },
+    attributeList: AttributeList,
+    statementList: StatementList,
+  ) {
+    this.attributeList = attributeList;
+    this.statementList = statementList;
+    this.node = {
+      id: id.value,
+      presence: attributeList.presence(),
+      layout: attributeList.nodeAttributes,
+    };
+  }
+
+  fill(g: LayoutGraph) {
+    g.setNode(this.node.id, this.node);
+    this.attributeList.fill(this.node);
+    this.statementList.fill(g, this.node);
+  }
+
+  setParent(g: LayoutGraph, parent: Node) {
+    g.setParent(this.node.id, parent.id);
+  }
+
+  static from(
+    this: { name: string },
+    tokens: Tokenizer,
+    id: Token & {
+      type: typeof TokenType.ID;
+    },
+  ) {
+    let attributes = AttributeList.Empty();
+    let token = tokens.peek();
+    if (token.type === TokenType.OpenAttr) {
+      attributes = AttributeList.from(tokens);
+      token = tokens.peek();
+      if (token.type === TokenType.CloseBlock) {
+        return new NodeStatement(id, attributes, StatementList.Empty());
+      }
+    }
+    if (token.type === TokenType.OpenBlock) {
+      const statements = StatementList.from(tokens);
+      token = tokens.peek();
+      if (token.type === TokenType.Semi) {
+        tokens.next();
+      }
+      return new NodeStatement(id, attributes, statements);
+    }
+
+    if (token.type === TokenType.Semi) {
+      tokens.next();
+      return new NodeStatement(id, attributes, StatementList.Empty());
+    }
+    tokens.parseError(NodeStatement.name, ";", token);
+    return new NodeStatement(id, attributes, StatementList.Empty());
+  }
+}
+
+class AttributeList implements AttributeSet {
+  private readonly attributes = new Map<string, Attribute>();
+  private constructor(attributes: Attribute[]) {
+    for (const attribute of attributes) {
+      this.attributes.set(attribute.id, attribute);
+    }
+  }
+
+  presence() {
+    const presence = this.asString("presence").toLowerCase();
+    switch (presence) {
+      case "left":
+        return ElementDiffPresence.LEFT;
+      case "right":
+        return ElementDiffPresence.RIGHT;
+      case "both":
+      default:
+        return ElementDiffPresence.BOTH;
+    }
+  }
+
+  asJson<T>(attr: string, def?: T): T | undefined {
+    try {
+      const attribute = this.attributes.get(attr.toLowerCase());
+      if (attribute) return JSON.parse(attribute.value) as T;
+    } catch {
+      // JSON parse error, ignore.
+    }
+    return def;
+  }
+
+  asNumber(attr: string, def = 0): number {
+    const attribute = this.attributes.get(attr.toLowerCase());
+    if (attribute) return Number(attribute.value);
+    return def;
+  }
+
+  asBoolean(attr: string, def = false): boolean {
+    const attribute = this.attributes.get(attr.toLowerCase());
+    if (attribute) {
+      const value = attribute.value.toLowerCase();
+      return value !== "0" && value !== "false";
+    }
+    return def;
+  }
+
+  asString(attr: string, def = ""): string {
+    const attribute = this.attributes.get(attr.toLowerCase());
+    if (attribute) return String(attribute.value);
+    return def;
+  }
+
+  hasAttribute(attr: string): boolean {
+    return this.attributes.has(attr.toLowerCase());
+  }
+
+  get nodeAttributes(): Partial<NodeConfig> {
+    const rank = this.asNumber("rank", 0);
+    const order = this.asNumber("order", -1);
+    const geometryParams = this.asJson<GeometryParams>("geometry");
+    const geometry = geometryParams ? parseGeometry(geometryParams) : new CircleGeometry();
+    const fixedRank = this.asBoolean("fixedRank", false);
+    return { rank, order, fixedRank, geometry };
+  }
+
+  get edgeAttributes(): Partial<EdgeConfig> {
+    const minLength = this.asNumber("minLength", 1);
+    const weight = this.asNumber("weight", 1);
+    const cutValue = this.asNumber("cutValue", 0);
+    return { minLength, weight, cutValue };
+  }
+
+  get graphAttributes(): Partial<GraphConfig> {
+    const edgeSep = this.asNumber("edgeSep", 10);
+    const nodeSep = this.asNumber("nodeSep", 50);
+    const rankSep = this.asNumber("rankSep", 50);
+    const timing = this.asBoolean("timing", false);
+    const printDebug = this.asBoolean("printDebug", false);
+    const hullRotation = this.asNumber("hullRotation", 25);
+    const bendLongEdges = this.asBoolean("bendLongEdges", true);
+    const childrenRelative = this.asBoolean("childrenRelative", true);
+    return {
+      edgeSep,
+      nodeSep,
+      rankSep,
+      timing,
+      printDebug,
+      hullRotation,
+      bendLongEdges,
+      childrenRelative,
+    };
+  }
+
+  // tslint:disable-next-line:enforce-name-casing
+  static Empty() {
+    return new AttributeList([]);
+  }
+
+  static from(this: { name: string }, tokens: Tokenizer): AttributeList {
+    const open = tokens.next();
+    if (open.type !== TokenType.OpenAttr) {
+      tokens.parseError(AttributeList.name, "[", open);
+    }
+    const attributes: Attribute[] = [];
+    while (tokens.hasNext) {
+      const token = tokens.peek();
+      if (token.type === TokenType.ID) {
+        const attribute = Attribute.from(tokens);
+        if (attribute) attributes.push(attribute);
+      } else if (token.type === TokenType.CloseAttr) {
+        tokens.next();
+        return new AttributeList(attributes);
+      } else {
+        tokens.parseError(AttributeList.name, "ID", token);
+        tokens.next();
+        return new AttributeList(attributes);
+      }
+    }
+    tokens.parseError(AttributeList.name, "]", open);
+    return AttributeList.Empty();
+  }
+
+  fill(o: unknown) {
+    if (this.attributes.size === 0) return;
+    (o as { data?: AttributeList }).data = this;
+    if (this.asBoolean("expanded")) {
+      (o as { expanded?: boolean }).expanded = true;
+    }
+  }
+}
+
+class Attribute {
+  readonly id: string;
+  readonly value: string;
+  private constructor(
+    id: Token & { type: typeof TokenType.ID },
+    value: Token & { type: typeof TokenType.Value | typeof TokenType.ID },
+  ) {
+    this.id = id.value.toLowerCase();
+    this.value = value.value;
+  }
+
+  static from(this: { name: string }, tokens: Tokenizer): Attribute | undefined {
+    const id = tokens.next();
+    if (id.type !== TokenType.ID) {
+      tokens.parseError(Attribute.name, "id", id);
+    }
+    const eq = tokens.next();
+    if (eq.type !== TokenType.Assign) {
+      tokens.parseError(Attribute.name, "=", eq);
+    }
+    const value = tokens.next();
+    if (
+      value.type === TokenType.Semi ||
+      value.type === TokenType.CloseAttr ||
+      value.type === TokenType.CloseBlock
+    ) {
+      return undefined;
+    }
+    if (value.type !== TokenType.Value && value.type !== TokenType.ID) {
+      tokens.parseError(Attribute.name, "value or id", value);
+      tokens.next();
+    }
+    const close = tokens.peek();
+    if (close.type === TokenType.Semi) {
+      tokens.next();
+    } else if (close.type !== TokenType.CloseAttr) {
+      tokens.parseError(Attribute.name, "; or ]", close);
+    }
+    return new Attribute(
+      id as Token & { type: typeof TokenType.ID },
+      value as Token & { type: typeof TokenType.Value | typeof TokenType.ID },
+    );
+  }
+}
+
+// tslint:disable:enforce-name-casing
+const TokenType = {
+  End: "END",
+  Digraph: "DIGRAPH",
+  OpenBlock: "OPEN_BLOCK",
+  CloseBlock: "CLOSE_BLOCK",
+  OpenAttr: "OPEN_ATTR",
+  CloseAttr: "CLOSE_ATTR",
+  Edge: "EDGE",
+  IncompleteEdge: "INCOMPLETE_EDGE",
+  Assign: "ASSIGN",
+  ID: "ID",
+  Value: "VALUE",
+  Semi: "SEMI",
+} as const;
+type TokenType = (typeof TokenType)[keyof typeof TokenType];
+// tslint:enable:enforce-name-casing
+
+class Token {
+  readonly type: TokenType;
+  readonly value: string;
+  readonly line: number;
+  readonly column: number;
+  readonly length: number;
+  constructor(type: TokenType, value: string, line: number, column: number, length = value.length) {
+    this.type = type;
+    this.value = value;
+    this.line = line;
+    this.column = column;
+    this.length = length;
+  }
+}
+
+interface Tokenizer {
+  readonly hasNext: boolean;
+  peek(): Token;
+  next(): Token;
+  readonly errors: Array<{}>;
+  parseError(node: string, expected: string, token: Token): void;
+}
+
+function tokenizer(text: string): Tokenizer {
+  const errors: Array<{}> = [];
+  let pos = 0;
+  let line = 1;
+  let column = 1;
+
+  function advance(n: number) {
+    column += n;
+    pos += n;
+    whitespace();
+  }
+
+  function whitespace() {
+    while (pos < text.length) {
+      if (text[pos] === "#") {
+        while (text[pos] !== "\n" && pos < text.length) {
+          increment();
+        }
+      }
+      if (text[pos].match(/\s/)) {
+        increment();
+      } else {
+        break;
+      }
+    }
+  }
+
+  function increment() {
+    if (text[pos] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+    pos++;
+  }
+
+  function token(type: TokenType, value: string, length = value.length) {
+    return new Token(type, value, line, column, length);
+  }
+
+  whitespace();
+
+  return {
+    get errors() {
+      return errors;
+    },
+    get hasNext() {
+      return pos < text.length;
+    },
+    peek() {
+      if (pos >= text.length) {
+        return token(TokenType.End, "");
+      }
+      const c = text.charAt(pos);
+      switch (c) {
+        case "{":
+          return token(TokenType.OpenBlock, c);
+        case "}":
+          return token(TokenType.CloseBlock, c);
+        case "[":
+          return token(TokenType.OpenAttr, c);
+        case "]":
+          return token(TokenType.CloseAttr, c);
+        case "=":
+          return token(TokenType.Assign, c);
+        case ";":
+          return token(TokenType.Semi, c);
+        case "-":
+          if (text.charAt(pos + 1) === ">") {
+            return token(TokenType.Edge, "->");
+          } else {
+            // A negative number, for a value ID.
+            return findEndId();
+          }
+        case '"':
+          return findEndQuote('"');
+        case "'":
+          return findEndQuote("'");
+        case "d":
+          if (text.substr(pos, pos + 7) === "digraph") {
+            return token(TokenType.Digraph, "digraph");
+          }
+          return findEndId();
+        default:
+          return findEndId();
+      }
+    },
+    next() {
+      const next = this.hasNext ? this.peek() : token(TokenType.End, "");
+      advance(next.length);
+      return next;
+    },
+    parseError(node: string, expected: string, got: Token) {
+      errors.push({ node, expected, got });
+    },
+  };
+
+  function findEndQuote(quoteType: '"' | "'"): Token {
+    let offset = 1;
+    while (offset + pos < text.length) {
+      // Find the closing quote, unless it is escaped
+      if (text[offset + pos] === quoteType && text[offset + pos - 1] !== "\\") {
+        break;
+      }
+      offset++;
+    }
+    const value = text
+      .slice(pos + 1, pos + offset)
+      .replace(new RegExp("\\\\" + quoteType, "g"), quoteType);
+    return token(TokenType.Value, value, offset + 1);
+  }
+
+  function findEndId() {
+    let offset = 1;
+    while (offset + pos < text.length) {
+      // Space and all the special characters above.
+      if (text.substr(offset + pos, 2) === "->") break;
+      if (/[\s=;"[\]{}]/.test(text.charAt(offset + pos))) break;
+      offset++;
+    }
+    const value = text.slice(pos, pos + offset);
+    return token(TokenType.ID, value);
+  }
+}