@speclynx/apidom-parser-adapter-yaml-1-2 1.12.2 → 2.0.1

package/src/tree-sitter/syntactic-analysis/CstTransformer.mjs

@@ -0,0 +1,618 @@
+import Error from "./ast/Error.mjs";
+import Literal from "./ast/Literal.mjs";
+import ParseResult from "./ast/ParseResult.mjs";
+import YamlAlias from "./ast/nodes/YamlAlias.mjs";
+import YamlAnchor from "./ast/nodes/YamlAnchor.mjs";
+import YamlComment from "./ast/nodes/YamlComment.mjs";
+import YamlDirective from "./ast/nodes/YamlDirective.mjs";
+import YamlDocument from "./ast/nodes/YamlDocument.mjs";
+import YamlKeyValuePair from "./ast/nodes/YamlKeyValuePair.mjs";
+import YamlMapping from "./ast/nodes/YamlMapping.mjs";
+import YamlScalar from "./ast/nodes/YamlScalar.mjs";
+import YamlSequence from "./ast/nodes/YamlSequence.mjs";
+import YamlStream from "./ast/nodes/YamlStream.mjs";
+import YamlTag, { YamlNodeKind } from "./ast/nodes/YamlTag.mjs";
+import { YamlStyle, YamlStyleGroup } from "./ast/nodes/YamlStyle.mjs";
+const getCursorInfo = cursor => ({
+  type: cursor.nodeType,
+  startPosition: cursor.startPosition,
+  endPosition: cursor.endPosition,
+  startIndex: cursor.startIndex,
+  endIndex: cursor.endIndex,
+  text: cursor.nodeText,
+  isNamed: cursor.nodeIsNamed,
+  isMissing: cursor.nodeIsMissing,
+  hasError: cursor.currentNode.hasError,
+  fieldName: cursor.currentFieldName
+});
+
+// Flat position properties extracted from CursorInfo
+
+const toPositionProps = info => ({
+  startLine: info.startPosition.row,
+  startCharacter: info.startPosition.column,
+  startOffset: info.startIndex,
+  endLine: info.endPosition.row,
+  endCharacter: info.endPosition.column,
+  endOffset: info.endIndex
+});
+const toYamlAnchor = info => {
+  return new YamlAnchor({
+    name: info.text,
+    ...toPositionProps(info)
+  });
+};
+const toYamlTag = (info, tagInfo) => {
+  const explicitName = tagInfo?.text || (info.type === 'plain_scalar' ? '?' : '!');
+  const kind = info.type.endsWith('mapping') ? YamlNodeKind.Mapping : info.type.endsWith('sequence') ? YamlNodeKind.Sequence : YamlNodeKind.Scalar;
+  const positionProps = tagInfo ? toPositionProps(tagInfo) : undefined;
+  return new YamlTag({
+    explicitName,
+    kind,
+    ...positionProps
+  });
+};
+const registerAnchor = (node, ctx) => {
+  if (node.anchor !== undefined) {
+    ctx.referenceManager.addAnchor(node);
+  }
+};
+
+// Using 'any' for TransformResult to avoid recursive type issues
+// The actual types are: YamlNode, YamlDirective, YamlDocument, YamlKeyValuePair, YamlComment, Literal, Error, ParseResult, arrays, or null
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// Helper to process children and track siblings for tag/anchor association
+const processChildren = (cursor, ctx, transformerMap) => {
+  const results = [];
+  let siblings = {};
+  if (cursor.gotoFirstChild()) {
+    do {
+      const info = getCursorInfo(cursor);
+
+      // Track tag and anchor siblings
+      if (info.type === 'tag') {
+        siblings.tag = info;
+        continue;
+      }
+      if (info.type === 'anchor') {
+        siblings.anchor = info;
+        continue;
+      }
+      const result = transform(cursor, ctx, transformerMap, siblings);
+      if (result !== null) {
+        results.push(result);
+      }
+
+      // Reset siblings after consuming them for a value node
+      if (info.type.endsWith('scalar') || info.type.endsWith('mapping') || info.type.endsWith('sequence') || info.type === 'block_node' || info.type === 'flow_node') {
+        siblings = {};
+      }
+    } while (cursor.gotoNextSibling());
+    cursor.gotoParent();
+  }
+  return results;
+};
+
+// Helper to process key-value pair children
+const processKeyValuePairChildren = (cursor, ctx, transformerMap) => {
+  let key = null;
+  let value = null;
+  const errors = [];
+  let siblings = {};
+  if (cursor.gotoFirstChild()) {
+    do {
+      const info = getCursorInfo(cursor);
+      const fieldName = cursor.currentFieldName;
+
+      // Track tag and anchor siblings
+      if (info.type === 'tag') {
+        siblings.tag = info;
+        continue;
+      }
+      if (info.type === 'anchor') {
+        siblings.anchor = info;
+        continue;
+      }
+      if (fieldName === 'key') {
+        key = transform(cursor, ctx, transformerMap, siblings);
+        siblings = {};
+      } else if (fieldName === 'value') {
+        value = transform(cursor, ctx, transformerMap, siblings);
+        siblings = {};
+      } else if (info.type === 'ERROR') {
+        const errorResult = transform(cursor, ctx, transformerMap, siblings);
+        if (errorResult !== null) {
+          errors.push(errorResult);
+        }
+      }
+    } while (cursor.gotoNextSibling());
+    cursor.gotoParent();
+  }
+  return {
+    key,
+    value,
+    errors
+  };
+};
+const transform = (cursor, ctx, transformerMap, siblings = {}) => {
+  const info = getCursorInfo(cursor);
+
+  // Handle missing anonymous literals
+  if (!info.isNamed && !info.isMissing) {
+    // Skip non-named, non-missing nodes (like punctuation)
+    return null;
+  }
+  if (!info.isNamed && info.isMissing) {
+    const nodeValue = info.type || info.text;
+    return new Literal({
+      value: nodeValue,
+      ...toPositionProps(info),
+      isMissing: true
+    });
+  }
+  const transformer = transformerMap[info.type];
+  if (!transformer) {
+    return null;
+  }
+  return transformer(cursor, ctx, siblings);
+};
+const createTransformers = transformerMap => ({
+  stream(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const children = processChildren(cursor, ctx, transformerMap);
+    const stream = new YamlStream({
+      children: children.filter(c => c !== null),
+      ...toPositionProps(info),
+      isMissing: info.isMissing
+    });
+    return new ParseResult({
+      children: [stream]
+    });
+  },
+  yaml_directive(cursor, _ctx) {
+    const info = getCursorInfo(cursor);
+
+    // Get version from first named child
+    let version;
+    if (cursor.gotoFirstChild()) {
+      do {
+        if (cursor.nodeIsNamed) {
+          version = cursor.nodeText;
+          break;
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    return new YamlDirective({
+      ...toPositionProps(info),
+      name: '%YAML',
+      parameters: {
+        version
+      }
+    });
+  },
+  tag_directive(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const children = [];
+    if (cursor.gotoFirstChild()) {
+      do {
+        if (cursor.nodeIsNamed) {
+          children.push(cursor.nodeText);
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    const tagDirective = new YamlDirective({
+      ...toPositionProps(info),
+      name: '%TAG',
+      parameters: {
+        handle: children[0],
+        prefix: children[1]
+      }
+    });
+    ctx.schema.registerTagDirective(tagDirective);
+    return tagDirective;
+  },
+  reserved_directive(cursor, _ctx) {
+    const info = getCursorInfo(cursor);
+    const children = [];
+    if (cursor.gotoFirstChild()) {
+      do {
+        if (cursor.nodeIsNamed) {
+          children.push(cursor.nodeText);
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    return new YamlDirective({
+      ...toPositionProps(info),
+      name: children[0],
+      parameters: {
+        handle: children[1],
+        prefix: children[2]
+      }
+    });
+  },
+  document(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const children = processChildren(cursor, ctx, transformerMap);
+    return new YamlDocument({
+      children: children.flat().filter(c => c !== null),
+      ...toPositionProps(info),
+      isMissing: info.isMissing
+    });
+  },
+  block_node(cursor, ctx, _siblings) {
+    // Block node is a wrapper - return its children
+    const children = processChildren(cursor, ctx, transformerMap);
+    return children;
+  },
+  flow_node(cursor, ctx, siblings) {
+    // Check if there's a kind node (scalar, mapping, or sequence)
+    let hasKindNode = false;
+    let lastChildInfo = null;
+    if (cursor.gotoFirstChild()) {
+      do {
+        const childInfo = getCursorInfo(cursor);
+        lastChildInfo = childInfo;
+        if (childInfo.type.endsWith('scalar') || childInfo.type.endsWith('mapping') || childInfo.type.endsWith('sequence')) {
+          hasKindNode = true;
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    if (hasKindNode) {
+      const children = processChildren(cursor, ctx, transformerMap);
+      return children;
+    }
+
+    // No kind node - create empty scalar
+    if (lastChildInfo) {
+      const emptyScalarNode = new YamlScalar({
+        content: '',
+        anchor: siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined,
+        tag: toYamlTag(lastChildInfo, siblings.tag),
+        startLine: lastChildInfo.endPosition.row,
+        startCharacter: lastChildInfo.endPosition.column,
+        startOffset: lastChildInfo.endIndex,
+        endLine: lastChildInfo.endPosition.row,
+        endCharacter: lastChildInfo.endPosition.column,
+        endOffset: lastChildInfo.endIndex,
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      registerAnchor(emptyScalarNode, ctx);
+      return emptyScalarNode;
+    }
+    return [];
+  },
+  block_mapping(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const children = processChildren(cursor, ctx, transformerMap);
+    const mappingNode = new YamlMapping({
+      children: children.filter(c => c !== null),
+      ...toPositionProps(info),
+      anchor,
+      tag,
+      styleGroup: YamlStyleGroup.Block,
+      style: YamlStyle.NextLine,
+      isMissing: info.isMissing
+    });
+    registerAnchor(mappingNode, ctx);
+    return ctx.schema.resolve(mappingNode);
+  },
+  block_mapping_pair(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const {
+      key,
+      value,
+      errors
+    } = processKeyValuePairChildren(cursor, ctx, transformerMap);
+    const children = [];
+
+    // Handle empty key
+    if (key === null) {
+      const emptyKey = new YamlScalar({
+        content: '',
+        startLine: info.startPosition.row,
+        startCharacter: info.startPosition.column,
+        startOffset: info.startIndex,
+        endLine: info.startPosition.row,
+        endCharacter: info.startPosition.column,
+        endOffset: info.startIndex,
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      children.push(emptyKey);
+    } else {
+      children.push(key);
+    }
+
+    // Handle empty value
+    if (value === null) {
+      const emptyValue = new YamlScalar({
+        content: '',
+        startLine: info.endPosition.row,
+        startCharacter: info.endPosition.column,
+        startOffset: info.endIndex,
+        endLine: info.endPosition.row,
+        endCharacter: info.endPosition.column,
+        endOffset: info.endIndex,
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      children.push(emptyValue);
+    } else {
+      children.push(value);
+    }
+    children.push(...errors);
+    return new YamlKeyValuePair({
+      children: children.flat().filter(c => c !== null),
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Block,
+      isMissing: info.isMissing
+    });
+  },
+  flow_mapping(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const children = processChildren(cursor, ctx, transformerMap);
+    const mappingNode = new YamlMapping({
+      children: children.flat().filter(c => c !== null),
+      ...toPositionProps(info),
+      anchor,
+      tag,
+      styleGroup: YamlStyleGroup.Flow,
+      style: YamlStyle.Explicit,
+      isMissing: info.isMissing
+    });
+    registerAnchor(mappingNode, ctx);
+    return ctx.schema.resolve(mappingNode);
+  },
+  flow_pair(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const {
+      key,
+      value,
+      errors
+    } = processKeyValuePairChildren(cursor, ctx, transformerMap);
+    const children = [];
+
+    // Handle empty key
+    if (key === null) {
+      const emptyKey = new YamlScalar({
+        content: '',
+        startLine: info.startPosition.row,
+        startCharacter: info.startPosition.column,
+        startOffset: info.startIndex,
+        endLine: info.startPosition.row,
+        endCharacter: info.startPosition.column,
+        endOffset: info.startIndex,
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      children.push(emptyKey);
+    } else {
+      children.push(key);
+    }
+
+    // Handle empty value
+    if (value === null) {
+      const emptyValue = new YamlScalar({
+        content: '',
+        startLine: info.endPosition.row,
+        startCharacter: info.endPosition.column,
+        startOffset: info.endIndex,
+        endLine: info.endPosition.row,
+        endCharacter: info.endPosition.column,
+        endOffset: info.endIndex,
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      children.push(emptyValue);
+    } else {
+      children.push(value);
+    }
+    children.push(...errors);
+    return new YamlKeyValuePair({
+      children: children.flat().filter(c => c !== null),
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Flow,
+      isMissing: info.isMissing
+    });
+  },
+  block_sequence(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const children = processChildren(cursor, ctx, transformerMap);
+    const sequenceNode = new YamlSequence({
+      children: children.flat(Infinity).filter(c => c !== null),
+      ...toPositionProps(info),
+      anchor,
+      tag,
+      styleGroup: YamlStyleGroup.Block,
+      style: YamlStyle.NextLine
+    });
+    registerAnchor(sequenceNode, ctx);
+    return ctx.schema.resolve(sequenceNode);
+  },
+  block_sequence_item(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const children = processChildren(cursor, ctx, transformerMap);
+
+    // If only one child (the "-" literal), create empty node
+    if (children.length === 0) {
+      const emptyScalarNode = new YamlScalar({
+        content: '',
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        startLine: info.endPosition.row,
+        startCharacter: info.endPosition.column,
+        startOffset: info.endIndex,
+        endLine: info.endPosition.row,
+        endCharacter: info.endPosition.column,
+        endOffset: info.endIndex,
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      return [emptyScalarNode];
+    }
+    return children;
+  },
+  flow_sequence(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const children = processChildren(cursor, ctx, transformerMap);
+    const sequenceNode = new YamlSequence({
+      children: children.flat().filter(c => c !== null),
+      ...toPositionProps(info),
+      anchor,
+      tag,
+      styleGroup: YamlStyleGroup.Flow,
+      style: YamlStyle.Explicit
+    });
+    registerAnchor(sequenceNode, ctx);
+    return ctx.schema.resolve(sequenceNode);
+  },
+  plain_scalar(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const scalarNode = new YamlScalar({
+      content: info.text,
+      anchor,
+      tag,
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Flow,
+      style: YamlStyle.Plain
+    });
+    registerAnchor(scalarNode, ctx);
+    return ctx.schema.resolve(scalarNode);
+  },
+  single_quote_scalar(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const scalarNode = new YamlScalar({
+      content: info.text,
+      anchor,
+      tag,
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Flow,
+      style: YamlStyle.SingleQuoted
+    });
+    registerAnchor(scalarNode, ctx);
+    return ctx.schema.resolve(scalarNode);
+  },
+  double_quote_scalar(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const scalarNode = new YamlScalar({
+      content: info.text,
+      anchor,
+      tag,
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Flow,
+      style: YamlStyle.DoubleQuoted
+    });
+    registerAnchor(scalarNode, ctx);
+    return ctx.schema.resolve(scalarNode);
+  },
+  block_scalar(cursor, ctx, siblings) {
+    const info = getCursorInfo(cursor);
+    const tag = toYamlTag(info, siblings.tag);
+    const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
+    const style = info.text.startsWith('|') ? YamlStyle.Literal : info.text.startsWith('>') ? YamlStyle.Folded : YamlStyle.Plain;
+    const scalarNode = new YamlScalar({
+      content: info.text,
+      anchor,
+      tag,
+      ...toPositionProps(info),
+      styleGroup: YamlStyleGroup.Block,
+      style
+    });
+    registerAnchor(scalarNode, ctx);
+    return ctx.schema.resolve(scalarNode);
+  },
+  comment(cursor) {
+    const info = getCursorInfo(cursor);
+    return new YamlComment({
+      content: info.text
+    });
+  },
+  alias(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const alias = new YamlAlias({
+      content: info.text
+    });
+    return ctx.referenceManager.resolveAlias(alias);
+  },
+  ERROR(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const children = processChildren(cursor, ctx, transformerMap);
+    const errorNode = new Error({
+      children: children.filter(c => c !== null),
+      ...toPositionProps(info),
+      isUnexpected: !info.hasError,
+      isMissing: info.isMissing,
+      value: info.text
+    });
+
+    // If at root level, wrap in ParseResult
+    // This check is simplified - we'll handle it in the main analyze function
+    return errorNode;
+  }
+});
+
+// Create transformers with self-reference for recursion
+const transformers = {};
+Object.assign(transformers, createTransformers(transformers));
+
+/**
+ * Transform TreeSitter CST directly to YAML AST using cursor-based traversal.
+ */
+export const transformCstToYamlAst = (cursor, ctx) => {
+  const result = transform(cursor, ctx, transformers);
+  if (result === null) {
+    return new ParseResult({
+      children: []
+    });
+  }
+  if (result instanceof ParseResult) {
+    return result;
+  }
+  if (result instanceof Error) {
+    return new ParseResult({
+      children: [result]
+    });
+  }
+  return new ParseResult({
+    children: [result]
+  });
+};
+export default transformCstToYamlAst;