@ts-graphviz/ast 0.0.0-pr956-20240225073457

package/src/dot-shim/parser/parse.ts

@@ -0,0 +1,121 @@
+import type {
+  ASTNode,
+  AttributeASTNode,
+  AttributeListASTNode,
+  ClusterStatementASTNode,
+  DotASTNode,
+  EdgeASTNode,
+  GraphASTNode,
+  NodeASTNode,
+  SubgraphASTNode,
+} from '../../types.js';
+import { PeggySyntaxError, parse as _parse } from './_parse.js';
+/**
+ * @group Convert DOT to AST
+ */
+export type Rule =
+  | 'Dot'
+  | 'Graph'
+  | 'Node'
+  | 'Edge'
+  | 'AttributeList'
+  | 'Attribute'
+  | 'Subgraph'
+  | 'ClusterStatements';
+
+/**
+ * CommonParseOptions is an interface that defines the properties needed in order to parse a file.
+ * @group Convert DOT to AST
+ */
+export interface CommonParseOptions {
+  /**
+   * filename (optional): A string value that is used to identify the file to be parsed.
+   */
+  filename?: string;
+}
+
+/**
+ * ParseOptions interface is used to provide additional information to the parser while parsing a rule.
+ * @template T The type of the rule to be parsed.
+ * @group Convert DOT to AST
+ */
+export interface ParseOptions<T extends Rule> extends CommonParseOptions {
+  startRule?: T;
+}
+
+/**
+ * parse is a function that takes a string input and optional parse options and
+ * returns an ASTNode or an array of ClusterStatementASTNodes.
+ *
+ * Depending on the type of parse option specified, the function will return different types of ASTNodes.
+ *
+ * The types of ASTNodes that can be returned are:
+ *
+ * - {@link DotASTNode}
+ * - {@link GraphASTNode}
+ * - {@link NodeASTNode}
+ * - {@link EdgeASTNode}
+ * - {@link AttributeListASTNode}
+ * - {@link AttributeASTNode}
+ * - {@link SubgraphASTNode}
+ * - {@link ClusterStatementASTNode}
+ *
+ * @throws {@link SyntaxError}
+ * @group Convert DOT to AST
+ */
+export function parse(input: string): DotASTNode;
+export function parse(input: string, options?: ParseOptions<'Dot'>): DotASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'Graph'>,
+): GraphASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'Node'>,
+): NodeASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'Edge'>,
+): EdgeASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'AttributeList'>,
+): AttributeListASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'Attribute'>,
+): AttributeASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'Subgraph'>,
+): SubgraphASTNode;
+export function parse(
+  input: string,
+  options?: ParseOptions<'ClusterStatements'>,
+): ClusterStatementASTNode[];
+export function parse(
+  input: string,
+  options?: ParseOptions<Rule>,
+): ASTNode | ClusterStatementASTNode[];
+export function parse(
+  input: string,
+  options?: ParseOptions<Rule>,
+): ASTNode | ClusterStatementASTNode[] {
+  try {
+    return _parse(input, options);
+  } catch (e) {
+    if (e instanceof PeggySyntaxError) {
+      throw new DotSyntaxError(e.message, e.expected, e.found, e.location);
+    }
+    throw e;
+  }
+}
+/**
+ * @group Convert DOT to AST
+ */
+export class DotSyntaxError extends PeggySyntaxError {
+  constructor(...args: ConstructorParameters<typeof PeggySyntaxError>) {
+    super(...args);
+    this.name = 'DotSyntaxError';
+  }
+}

package/src/dot-shim/parser/peggy.options.json

@@ -0,0 +1,15 @@
+{
+  "allowedStartRules": [
+    "Dot",
+    "Graph",
+    "Subgraph",
+    "Node",
+    "Edge",
+    "AttributeList",
+    "Attribute",
+    "ClusterStatements"
+  ],
+  "tspegjs": {
+    "customHeader": "import { Builder } from '../../builder/index.js';"
+  }
+}

package/src/dot-shim/printer/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module ts-graphviz/printer
+ */
+export * from './types.js';
+export * from './printer.js';
+export * from './stringify.js';

package/src/dot-shim/printer/plugins/AttributeListPrintPlugin.ts

@@ -0,0 +1,22 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { ASTNode, AttributeListASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine, indent, joinBy, wrapByPair } from './utils/index.js';
+
+export const AttributeListPrintPlugin: PrintPlugin<AttributeListASTNode> = {
+  match(ast: ASTNode) {
+    return ast.type === 'AttributeList';
+  },
+  print(context, ast): string {
+    if (ast.children.length === 0) {
+      return `${ast.kind.toLocaleLowerCase()} [];`;
+    }
+    const eol = endOfLine(context.endOfLine);
+    return pipe(
+      map(context.print),
+      joinBy(eol),
+      indent(context.indentStyle, context.indentSize, eol),
+      wrapByPair(`${ast.kind.toLocaleLowerCase()} [${eol}`, `${eol}];`),
+    )(ast.children);
+  },
+};

package/src/dot-shim/printer/plugins/AttributePrintPlugin.ts

@@ -0,0 +1,11 @@
+import { ASTNode, AttributeASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+
+export const AttributePrintPlugin: PrintPlugin<AttributeASTNode> = {
+  match(ast: ASTNode) {
+    return ast.type === 'Attribute';
+  },
+  print(context, ast): string {
+    return `${context.print(ast.key)} = ${context.print(ast.value)};`;
+  },
+};

package/src/dot-shim/printer/plugins/CommentPrintPlugin.ts

@@ -0,0 +1,40 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { CommentASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import {
+  endOfLine,
+  joinBy,
+  leftPadWith,
+  splitByLine,
+  wrapByPair,
+} from './utils/index.js';
+
+export const CommentPrintPlugin: PrintPlugin<CommentASTNode> = {
+  match(ast) {
+    return ast.type === 'Comment';
+  },
+  print(context, ast): string {
+    const eol = endOfLine(context.endOfLine);
+    switch (ast.kind) {
+      case 'Block':
+        return pipe(
+          splitByLine,
+          map(leftPadWith(' * ')),
+          joinBy(eol),
+          wrapByPair(`/**${eol}`, `${eol} */`),
+        )(ast.value);
+      case 'Macro':
+        return pipe(
+          splitByLine,
+          map(leftPadWith('# ')),
+          joinBy(eol),
+        )(ast.value);
+      default:
+        return pipe(
+          splitByLine,
+          map(leftPadWith('// ')),
+          joinBy(eol),
+        )(ast.value);
+    }
+  },
+};

package/src/dot-shim/printer/plugins/DotPrintPlugin.ts

@@ -0,0 +1,12 @@
+import { DotASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine } from './utils/index.js';
+
+export const DotPrintPlugin: PrintPlugin<DotASTNode> = {
+  match(ast) {
+    return ast.type === 'Dot';
+  },
+  print(context, ast): string {
+    return ast.children.map(context.print).join(endOfLine(context.endOfLine));
+  },
+};

package/src/dot-shim/printer/plugins/EdgePrintPlugin.ts

@@ -0,0 +1,27 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { EdgeASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine, indent, joinBy, wrapByPair } from './utils/index.js';
+
+export const EdgePrintPlugin: PrintPlugin<EdgeASTNode> = {
+  match(ast) {
+    return ast.type === 'Edge';
+  },
+  print(context, ast): string {
+    const targets = pipe(
+      map(context.print),
+      joinBy(context.directed ? ' -> ' : ' -- '),
+    )(ast.targets);
+    if (ast.children.length === 0) {
+      return `${targets};`;
+    }
+    const eol = endOfLine(context.endOfLine);
+    const contents = pipe(
+      map(context.print),
+      joinBy(eol),
+      indent(context.indentStyle, context.indentSize, eol),
+      wrapByPair(`[${eol}`, `${eol}];`),
+    )(ast.children);
+    return `${targets} ${contents}`;
+  },
+};

package/src/dot-shim/printer/plugins/GraphPrintPlugin.ts

@@ -0,0 +1,32 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { GraphASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine, indent, joinBy, wrapByPair } from './utils/index.js';
+
+export const GraphPrintPlugin: PrintPlugin<GraphASTNode> = {
+  match(ast) {
+    return ast.type === 'Graph';
+  },
+  print(context, ast): string {
+    context.directed = ast.directed;
+    const parts: string[] = [];
+    if (ast.strict) {
+      parts.push('strict');
+    }
+    parts.push(ast.directed ? 'digraph' : 'graph');
+    if (ast.id) {
+      parts.push(context.print(ast.id));
+    }
+    if (ast.children.length === 0) {
+      return `${parts.join(' ')} {}`;
+    }
+    const eol = endOfLine(context.endOfLine);
+    const contents = pipe(
+      map(context.print),
+      joinBy(eol),
+      indent(context.indentStyle, context.indentSize, eol),
+      wrapByPair(`{${eol}`, `${eol}}`),
+    )(ast.children);
+    return `${parts.join(' ')} ${contents}`;
+  },
+};

package/src/dot-shim/printer/plugins/LiteralPrintPlugin.ts

@@ -0,0 +1,24 @@
+import { pipe } from '@ts-graphviz/common';
+import { LiteralASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { escape, wrapByPair, wrapWith } from './utils/index.js';
+
+const quoteLiteralValue = pipe(escape, wrapWith('"'));
+
+const quoteHTMLLikeLiteralValue = wrapByPair('<', '>');
+
+export const LiteralPrintPlugin: PrintPlugin<LiteralASTNode> = {
+  match(ast) {
+    return ast.type === 'Literal';
+  },
+  print(context, ast): string {
+    switch (ast.quoted) {
+      case 'html':
+        return quoteHTMLLikeLiteralValue(ast.value);
+      case true:
+        return quoteLiteralValue(ast.value);
+      default:
+        return escape(ast.value);
+    }
+  },
+};

package/src/dot-shim/printer/plugins/NodePrintPlugin.ts

@@ -0,0 +1,24 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { NodeASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine, indent, joinBy, wrapByPair } from './utils/index.js';
+
+export const NodePrintPlugin: PrintPlugin<NodeASTNode> = {
+  match(ast) {
+    return ast.type === 'Node';
+  },
+  print(context, ast): string {
+    const id = context.print(ast.id);
+    if (ast.children.length === 0) {
+      return `${id};`;
+    }
+    const eol = endOfLine(context.endOfLine);
+    const contents = pipe(
+      map(context.print),
+      joinBy(eol),
+      indent(context.indentStyle, context.indentSize, eol),
+      wrapByPair(`[${eol}`, `${eol}];`),
+    )(ast.children);
+    return `${id} ${contents}`;
+  },
+};

package/src/dot-shim/printer/plugins/NodeRefGroupPrintPlugin.ts

@@ -0,0 +1,17 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { NodeRefGroupASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { joinBy, wrapByPair } from './utils/index.js';
+
+export const NodeRefGroupPrintPlugin: PrintPlugin<NodeRefGroupASTNode> = {
+  match(ast) {
+    return ast.type === 'NodeRefGroup';
+  },
+  print(context, ast): string {
+    return pipe(
+      map(context.print),
+      joinBy(' '),
+      wrapByPair('{', '}'),
+    )(ast.children);
+  },
+};

package/src/dot-shim/printer/plugins/NodeRefPrintPlugin.ts

@@ -0,0 +1,18 @@
+import { NodeRefASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+
+export const NodeRefPrintPlugin: PrintPlugin<NodeRefASTNode> = {
+  match(ast) {
+    return ast.type === 'NodeRef';
+  },
+  print(context, ast): string {
+    const parts = [context.print(ast.id)];
+    if (ast.port) {
+      parts.push(context.print(ast.port));
+    }
+    if (ast.compass) {
+      parts.push(context.print(ast.compass));
+    }
+    return parts.join(':');
+  },
+};

package/src/dot-shim/printer/plugins/SubgraphPrintPlugin.ts

@@ -0,0 +1,27 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { SubgraphASTNode } from '../../../types.js';
+import { PrintPlugin } from '../types.js';
+import { endOfLine, indent, joinBy, wrapByPair } from './utils/index.js';
+
+export const SubgraphPrintPlugin: PrintPlugin<SubgraphASTNode> = {
+  match(ast) {
+    return ast.type === 'Subgraph';
+  },
+  print(context, ast): string {
+    const parts: string[] = ['subgraph'];
+    if (ast.id) {
+      parts.push(context.print(ast.id));
+    }
+    if (ast.children.length === 0) {
+      return `${parts.join(' ')} {}`;
+    }
+    const eol = endOfLine(context.endOfLine);
+    const contents = pipe(
+      map(context.print),
+      joinBy(eol),
+      indent(context.indentStyle, context.indentSize, eol),
+      wrapByPair(`{${eol}`, `${eol}}`),
+    )(ast.children);
+    return `${parts.join(' ')} ${contents}`;
+  },
+};

package/src/dot-shim/printer/plugins/index.ts

@@ -0,0 +1,26 @@
+import { PrintPlugin } from '../types.js';
+import { AttributeListPrintPlugin } from './AttributeListPrintPlugin.js';
+import { AttributePrintPlugin } from './AttributePrintPlugin.js';
+import { CommentPrintPlugin } from './CommentPrintPlugin.js';
+import { DotPrintPlugin } from './DotPrintPlugin.js';
+import { EdgePrintPlugin } from './EdgePrintPlugin.js';
+import { GraphPrintPlugin } from './GraphPrintPlugin.js';
+import { LiteralPrintPlugin } from './LiteralPrintPlugin.js';
+import { NodePrintPlugin } from './NodePrintPlugin.js';
+import { NodeRefGroupPrintPlugin } from './NodeRefGroupPrintPlugin.js';
+import { NodeRefPrintPlugin } from './NodeRefPrintPlugin.js';
+import { SubgraphPrintPlugin } from './SubgraphPrintPlugin.js';
+
+export const defaultPlugins: PrintPlugin[] = [
+  AttributeListPrintPlugin,
+  AttributePrintPlugin,
+  CommentPrintPlugin,
+  DotPrintPlugin,
+  EdgePrintPlugin,
+  GraphPrintPlugin,
+  LiteralPrintPlugin,
+  NodePrintPlugin,
+  NodeRefGroupPrintPlugin,
+  NodeRefPrintPlugin,
+  SubgraphPrintPlugin,
+];

package/src/dot-shim/printer/plugins/utils/index.ts

@@ -0,0 +1 @@
+export * from './tokens.js';

package/src/dot-shim/printer/plugins/utils/tokens.ts

@@ -0,0 +1,51 @@
+import { map, pipe } from '@ts-graphviz/common';
+import { EndOfLine, IndentStyle } from '../../types.js';
+
+const EOL = /\r?\n/;
+
+export function joinBy(sep: string): (value: string[]) => string {
+  return (value: string[]) => value.join(sep);
+}
+
+export function wrapWith(wrapper: string): (value: string) => string {
+  return (value: string) => wrapper + value + wrapper;
+}
+
+export function wrapByPair(l: string, r: string): (value: string) => string {
+  return (value: string) => l + value + r;
+}
+
+export function leftPadWith(left: string): (value: string) => string {
+  return (value: string) => left + value;
+}
+
+export function rightPadWith(right: string): (value: string) => string {
+  return (value: string) => value + right;
+}
+
+export const escape = (value: string): string =>
+  value
+    .replace(/\\/g, '\\\\')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/"/g, '\\"');
+export const splitByLine = (value: string): string[] => value.split(EOL);
+
+export const align = (padding: string, eol: string) =>
+  pipe(splitByLine, map(leftPadWith(padding)), joinBy(eol));
+
+export const indent = (style: IndentStyle, size: number, eol: string) =>
+  pipe(
+    splitByLine,
+    map(leftPadWith(style === 'space' ? ' '.repeat(size) : '\n')),
+    joinBy(eol),
+  );
+
+export const endOfLine = (eol: EndOfLine) => {
+  switch (eol) {
+    case 'crlf':
+      return '\r\n';
+    case 'lf':
+      return '\n';
+  }
+};

package/src/dot-shim/printer/printer.ts

@@ -0,0 +1,46 @@
+import type { ASTNode } from '../../types.js';
+import { defaultPlugins } from './plugins/index.js';
+import type { PrintContext, PrintOptions, PrintPlugin } from './types.js';
+
+/**
+ * Printer is a class responsible for converting an AST into a DOT string.
+ * @group Convert AST to DOT
+ */
+export class Printer {
+  /** @internal */
+  #plugins: PrintPlugin[] = [...defaultPlugins];
+
+  /**
+   * @param options Options to be used when generating the DOT string.
+   */
+  constructor(private options: PrintOptions = {}) {}
+
+  /**
+   * Generates a DOT string from an ASTNode.
+   * @param ast The ASTNode to be converted into a DOT string.
+   * @returns The DOT string generated from the ASTNode.
+   */
+  public print(ast: ASTNode): string {
+    const plugins = [...this.#plugins];
+    const {
+      indentSize = 2,
+      indentStyle = 'space',
+      endOfLine = 'lf',
+    } = this.options;
+    const context: PrintContext = {
+      directed: true,
+      indentSize,
+      indentStyle,
+      endOfLine,
+      print(a: ASTNode): string {
+        for (const plugin of plugins) {
+          if (plugin.match(a)) {
+            return plugin.print(context, a);
+          }
+        }
+        throw Error();
+      },
+    };
+    return context.print(ast);
+  }
+}