clarity-pattern-parser 4.0.3 → 6.0.0

package/src/Cursor.ts

@@ -1,141 +0,0 @@
-import Pattern from "./patterns/Pattern";
-import Node from "./ast/Node";
-import CursorHistory from "./CursorHistory";
-import ParseError from "./patterns/ParseError";
-
-export default class Cursor {
-  public text: string;
-  public index: number;
-  public length: number;
-  public history: CursorHistory;
-  public isInErrorState: boolean;
-
-  constructor(text: string) {
-    this.text = text;
-    this.assertValidity();
-
-    this.index = 0;
-    this.length = text.length;
-    this.history = new CursorHistory();
-    this.isInErrorState = false;
-  }
-
-  assertValidity() {
-    if (this.isNullOrEmpty(this.text)) {
-      throw new Error(
-        "Illegal Argument: Cursor needs to have a string that has a length greater than 0."
-      );
-    }
-  }
-
-  startRecording() {
-    this.history.startRecording();
-  }
-
-  stopRecording() {
-    this.history.stopRecording();
-  }
-
-  get parseError() {
-    return this.history.getFurthestError();
-  }
-
-  get lastMatch() {
-    return this.history.getFurthestMatch();
-  }
-
-  throwError(parseError: ParseError) {
-    this.isInErrorState = true;
-    this.history.addError(parseError);
-  }
-
-  addMatch(pattern: Pattern, astNode: Node) {
-    this.history.addMatch(pattern, astNode);
-  }
-
-  resolveError() {
-    this.isInErrorState = false;
-  }
-
-  hasUnresolvedError() {
-    return this.isInErrorState;
-  }
-
-  isNullOrEmpty(value: string | null) {
-    return value == null || (typeof value === "string" && value.length === 0);
-  }
-
-  hasNext() {
-    return this.index + 1 < this.text.length;
-  }
-
-  hasPrevious() {
-    return this.index - 1 >= 0;
-  }
-
-  next() {
-    if (this.hasNext()) {
-      this.index++;
-    } else {
-      throw new Error("Cursor: Out of Bounds Exception.");
-    }
-  }
-
-  previous() {
-    if (this.hasPrevious()) {
-      this.index--;
-    } else {
-      throw new Error("Cursor: Out of Bounds Exception.");
-    }
-  }
-
-  mark() {
-    return this.index;
-  }
-
-  moveToMark(mark: number) {
-    this.index = mark;
-  }
-
-  moveToBeginning() {
-    this.index = 0;
-  }
-
-  moveToEnd() {
-    this.index = this.text.length - 1;
-  }
-
-  getChar() {
-    return this.text.charAt(this.index);
-  }
-
-  getIndex() {
-    return this.index;
-  }
-
-  setIndex(index: number) {
-    if (typeof index === "number") {
-      if (index < 0 || index > this.lastIndex()) {
-        throw new Error("Cursor: Out of Bounds Exception.");
-      }
-
-      this.index = index;
-    }
-  }
-
-  isAtBeginning() {
-    return this.index === 0;
-  }
-
-  isAtEnd() {
-    return this.index === this.text.length - 1;
-  }
-
-  lastIndex() {
-    return this.length - 1;
-  }
-
-  didSuccessfullyParse() {
-    return !this.hasUnresolvedError() && this.isAtEnd();
-  }
-}

package/src/CursorHistory.ts

@@ -1,146 +0,0 @@
-import Pattern from "./patterns/Pattern";
-import Node from "./ast/Node";
-import ParseError from "./patterns/ParseError";
-
-export interface Match {
-  pattern: Pattern | null;
-  astNode: Node | null;
-}
-
-export default class CursorHistory {
-  public isRecording: boolean;
-  public furthestMatch: Match;
-  public furthestError: ParseError | null;
-  public patterns: Pattern[];
-  public astNodes: Node[];
-  public errors: ParseError[];
-
-  constructor() {
-    this.isRecording = false;
-
-    this.furthestMatch = {
-      pattern: null,
-      astNode: null,
-    };
-
-    this.furthestError = null;
-
-    this.patterns = [];
-    this.astNodes = [];
-    this.errors = [];
-  }
-
-  addMatch(pattern: Pattern, astNode: Node) {
-    if (this.isRecording) {
-      this.patterns.push(pattern);
-      this.astNodes.push(astNode);
-    }
-
-    if (
-      this.furthestMatch.astNode == null ||
-      astNode.endIndex >= this.furthestMatch.astNode.endIndex
-    ) {
-      this.furthestMatch.pattern = pattern;
-      this.furthestMatch.astNode = astNode;
-    }
-  }
-
-  addError(error: ParseError) {
-    if (this.isRecording) {
-      this.errors.push(error);
-    }
-
-    if (this.furthestError == null || error.index >= this.furthestError.index) {
-      this.furthestError = error;
-    }
-  }
-
-  startRecording() {
-    this.isRecording = true;
-  }
-
-  stopRecording() {
-    this.isRecording = false;
-    this.clear();
-  }
-
-  clear() {
-    this.patterns.length = 0;
-    this.astNodes.length = 0;
-    this.errors.length = 0;
-  }
-
-  getFurthestError() {
-    return this.furthestError;
-  }
-
-  getFurthestMatch() {
-    return this.furthestMatch;
-  }
-
-  getLastMatch() {
-    if (this.isRecording) {
-      return {
-        pattern: this.patterns[this.patterns.length - 1] || null,
-        astNode: this.astNodes[this.astNodes.length - 1] || null,
-      } as Match;
-    } else {
-      return this.furthestMatch as Match;
-    }
-  }
-
-  getLastError() {
-    return this.errors[this.errors.length - 1] || null;
-  }
-
-  getAllParseStacks() {
-    const stacks = this.astNodes.reduce((acc: Node[][], node) => {
-      let container: Node[] = acc[acc.length - 1];
-
-      if (node.startIndex === 0) {
-        container = [];
-        acc.push(container);
-      }
-
-      container.push(node);
-
-      return acc;
-    }, []);
-
-    // There are times when the matching will fail and hit again on the same node.
-    // This filters them out.
-    // We simply check to see if there is any overlap with the previous one,
-    // and if there is we don't add it. This is why we move backwards.
-    const cleanedStack = stacks.map((stack: Node[]) => {
-      const cleanedStack = [];
-
-      for (let x = stack.length - 1; x >= 0; x--) {
-        const currentNode = stack[x];
-        const previousNode = stack[x + 1];
-
-        if (previousNode == null) {
-          cleanedStack.unshift(currentNode);
-        } else {
-          const left = Math.max(
-            currentNode.startIndex,
-            previousNode.startIndex
-          );
-          const right = Math.min(currentNode.endIndex, previousNode.endIndex);
-          const isOverlapping = left <= right;
-
-          if (!isOverlapping) {
-            cleanedStack.unshift(currentNode);
-          }
-        }
-      }
-      return cleanedStack;
-    });
-
-    return cleanedStack;
-  }
-
-  getLastParseStack(): Node[] {
-    const stacks = this.getAllParseStacks();
-    return stacks[stacks.length - 1] || [];
-  }
-}

package/src/TextSuggester.ts

@@ -1,317 +0,0 @@
-import Node from "./ast/Node";
-import Cursor from "./Cursor";
-import { Match } from "./CursorHistory";
-import Pattern from "./patterns/Pattern";
-
-export interface Token {
-  startIndex: number;
-  values: string[];
-}
-
-export interface SuggestionError {
-  startIndex: number;
-  endIndex: number;
-  text: string;
-}
-
-export interface SuggestionMatch {
-  startIndex: number;
-  endIndex: number;
-  text: string;
-}
-
-export interface SuggestionResult {
-  pattern: Pattern | null;
-  astNode: Node | null;
-  match: SuggestionMatch | null;
-  error: SuggestionError | null;
-  options: Token;
-  isComplete: boolean;
-  parseStack: Node[];
-}
-
-export default class TextSuggester {
-  private cursor: Cursor | null = null;
-  private result: Node | null = null;
-  private text: string = "";
-  private match: SuggestionMatch | null = null;
-  private error: SuggestionError | null = null;
-  private patternMatch: Match | null = null;
-  private matchedText: string = "";
-  private rootPattern: Pattern | null = null;
-  private tokens: Token | null = {
-    startIndex: 0,
-    values: [],
-  };
-  private options: string[] = [];
-  private parseStack: Node[] = [];
-
-  suggest(text: string, pattern: Pattern) {
-    this.reset();
-
-    this.text = text;
-    this.rootPattern = pattern;
-
-    // If no text all options are available.
-    if (text.length === 0) {
-      return {
-        pattern: null,
-        astNode: null,
-        match: null,
-        error: null,
-        options: {
-          startIndex: 0,
-          values: pattern.getTokens(),
-        },
-        isComplete: false,
-        parseStack: [],
-      } as SuggestionResult;
-    }
-
-    this.parse();
-    this.saveParseStack();
-    this.saveMatchedText();
-    this.saveMatch();
-    this.saveError();
-    this.saveOptions();
-    this.saveNextToken();
-
-    return {
-      pattern: this.patternMatch?.pattern || null,
-      astNode: this.patternMatch?.astNode || null,
-      match: this.match,
-      error: this.error,
-      options: this.tokens,
-      isComplete: this.cursor?.didSuccessfullyParse() || false,
-      parseStack: this.parseStack,
-    } as SuggestionResult;
-  }
-
-  private reset() {
-    this.cursor = null;
-    this.result = null;
-    this.text = "";
-    this.match = null;
-    this.error = null;
-    this.patternMatch = null;
-    this.matchedText = "";
-    this.rootPattern = null;
-    this.tokens = {
-      startIndex: 0,
-      values: [],
-    };
-    this.options = [];
-    this.parseStack = [];
-  }
-
-  private parse() {
-    this.rootPattern = this.rootPattern;
-    this.cursor = new Cursor(this.text || "");
-    this.cursor.startRecording();
-    this.result = this.rootPattern?.parse(this.cursor) || null;
-    this.patternMatch = this.cursor.lastMatch;
-  }
-
-  private saveParseStack() {
-    this.parseStack = this.cursor?.history.getLastParseStack() || [];
-  }
-
-  private saveMatchedText() {
-    if (this.patternMatch?.astNode != null) {
-      this.matchedText =
-        this.text?.substring(0, this.patternMatch.astNode.endIndex + 1) || "";
-    }
-  }
-
-  private saveMatch() {
-    const node = this.patternMatch?.astNode;
-
-    if (node == null) {
-      this.match = null;
-      return;
-    }
-
-    let endIndex = this.matchedText.length - 1;
-
-    this.match = {
-      text: this.matchedText,
-      startIndex: 0,
-      endIndex: endIndex,
-    };
-  }
-
-  private saveError() {
-    if (this.patternMatch?.astNode == null) {
-      this.error = {
-        startIndex: 0,
-        endIndex: this.text.length - 1,
-        text: this.text,
-      };
-      return this;
-    }
-
-    if (
-      this.patternMatch != null &&
-      this.text.length > this.matchedText.length
-    ) {
-      const difference = this.text.length - this.matchedText.length;
-      const startIndex = this.patternMatch.astNode.endIndex + 1;
-      const endIndex = startIndex + difference - 1;
-
-      this.error = {
-        startIndex: startIndex,
-        endIndex: endIndex,
-        text: this.text.substring(startIndex, endIndex + 1),
-      };
-
-      return;
-    } else {
-      this.error = null;
-      return;
-    }
-  }
-
-  private saveNextToken() {
-    const isCompleteMatch =
-      this.patternMatch?.pattern === this.rootPattern &&
-      this.cursor?.didSuccessfullyParse();
-    const noMatch = this.patternMatch?.astNode == null;
-    const noOptions = this.options.length === 0;
-
-    if (isCompleteMatch && noOptions) {
-      this.tokens = null;
-      return;
-    }
-
-    if (noMatch) {
-      let options = this.rootPattern?.getTokens();
-
-      options = options?.filter((option: any) => {
-        return option.indexOf(this.text) === 0;
-      });
-
-      if (options?.length === 0) {
-        this.tokens = null;
-        return;
-      }
-
-      const values = options?.map((option) => {
-        const parts = option.split(this.text);
-        return parts[1];
-      });
-
-      this.tokens = {
-        startIndex: 0,
-        values: values || [],
-      };
-
-      this.matchedText = this.text;
-      this.match = {
-        text: this.text,
-        startIndex: 0,
-        endIndex: this.text.length - 1,
-      };
-      this.error = null;
-
-      return;
-    }
-
-    const options = this.options;
-    let startIndex = this.matchedText.length;
-
-    if (this.matchedText.length < this.text.length) {
-      const leftOver = this.text.substring(this.matchedText.length);
-      const partialMatchOptions = options
-        .filter((option: any) => {
-          return option.indexOf(leftOver) === 0;
-        })
-        .map((option: any) => {
-          return option.substring(leftOver.length);
-        });
-
-      if (partialMatchOptions.length === 0) {
-        this.tokens = null;
-        return;
-      } else {
-        if (this.match == null) {
-          return;
-        }
-
-        this.match = {
-          text: this.match.text + leftOver,
-          startIndex: this.match.startIndex,
-          endIndex: this.match.endIndex + leftOver.length,
-        };
-
-        this.error = null;
-
-        this.tokens = {
-          startIndex: this.match.endIndex + 1,
-          values: partialMatchOptions,
-        };
-
-        return;
-      }
-    }
-
-    this.tokens = {
-      startIndex,
-      values: options,
-    };
-  }
-
-  private saveOptions() {
-    const parents = new Map<Pattern, Pattern>();
-    const cursor = this.cursor;
-
-    if (cursor == null) {
-      this.options = [];
-      return;
-    }
-
-    const furthestMatches = cursor.history.astNodes.reduce(
-      (acc: any, node: any, index: any) => {
-        const pattern = cursor.history.patterns[index];
-        const parent = pattern.parent;
-
-        if (parent != null) {
-          parents.set(parent, parent);
-        }
-
-        if (parents.has(pattern)){
-          return acc;
-        }
-
-        if (node.endIndex === acc.furthestTextIndex) {
-          acc.nodeIndexes.push(index);
-        } else if (node.endIndex > acc.furthestTextIndex) {
-          acc.furthestTextIndex = node.endIndex;
-          acc.nodeIndexes = [index];
-        }
-
-        return acc;
-      },
-      { furthestTextIndex: -1, nodeIndexes: [] }
-    );
-
-    const matches = furthestMatches.nodeIndexes.reduce(
-      (acc: any, index: any) => {
-        const pattern = this.cursor?.history.patterns[index];
-        const tokens = pattern?.getNextTokens();
-
-        tokens?.forEach((token: any) => {
-          acc[token] = true;
-        });
-
-        return acc;
-      },
-      {}
-    );
-
-    this.options = Object.keys(matches);
-  }
-
-  static suggest(text: string, pattern: Pattern) {
-    return new TextSuggester().suggest(text, pattern);
-  }
-}