build: move regexp-to-ast package into this repo (#1947)

Co-authored-by: Luiz Guilherme D'Abruzzo Pereira <[email protected]>

packages/chevrotain/package.json

@@ -77,8 +77,8 @@
     "@chevrotain/gast": "10.5.0",
     "@chevrotain/types": "10.5.0",
     "@chevrotain/utils": "10.5.0",
-    "lodash": "4.17.21",
-    "regexp-to-ast": "0.5.0"
+    "@chevrotain/regexp-to-ast": "10.5.0",
+    "lodash": "4.17.21"
   },
   "devDependencies": {
     "@types/lodash": "4.14.191",

packages/chevrotain/src/scan/lexer.ts

@@ -1,4 +1,4 @@
-import { BaseRegExpVisitor } from "regexp-to-ast"
+import { BaseRegExpVisitor } from "@chevrotain/regexp-to-ast"
 import { IRegExpExec, Lexer, LexerDefinitionErrorType } from "./lexer_public"
 import first from "lodash/first"
 import isEmpty from "lodash/isEmpty"

packages/chevrotain/src/scan/reg_exp.ts

@@ -5,10 +5,8 @@ import {
   Character,
   Disjunction,
   Group,
-  Set,
-  Term,
-  VERSION
-} from "regexp-to-ast"
+  Set
+} from "@chevrotain/regexp-to-ast"
 import isArray from "lodash/isArray"
 import every from "lodash/every"
 import forEach from "lodash/forEach"
@@ -60,8 +58,8 @@ export function getOptimizedStartCodesIndices(
       PRINT_ERROR(
         `${failedOptimizationPrefixMsg}\n` +
           `\tFailed parsing: < ${regExp.toString()} >\n` +
-          `\tUsing the regexp-to-ast library version: ${VERSION}\n` +
-          "\tPlease open an issue at: https://github.com/bd82/regexp-to-ast/issues" +
+          `\tUsing the @chevrotain/regexp-to-ast library\n` +
+          "\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues" +
           msgSuffix
       )
     }

packages/chevrotain/src/scan/reg_exp_parser.ts

@@ -5,7 +5,7 @@ import {
   Disjunction,
   RegExpParser,
   RegExpPattern
-} from "regexp-to-ast"
+} from "@chevrotain/regexp-to-ast"
 
 let regExpAstCache: { [regex: string]: RegExpPattern } = {}
 const regExpParser = new RegExpParser()

packages/regexp-to-ast/.mocharc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  recursive: true,
+  require: ["source-map-support/register"],
+  reporter: "spec",
+  spec: "./lib/test/**/*spec.js"
+}

packages/regexp-to-ast/api.d.ts

@@ -0,0 +1,134 @@
+export class RegExpParser {
+  pattern: (input: string) => RegExpPattern
+}
+
+export interface IRegExpAST {
+  type: string
+  loc: Location
+}
+
+export interface Location {
+  begin: number
+  end: number
+}
+
+export type RegExpAstPart =
+  | RegExpPattern
+  | RegExpFlags
+  | Disjunction
+  | Alternative
+  | Atom
+  | Assertion
+  | Quantifier
+
+export interface RegExpPattern extends IRegExpAST {
+  type: "Pattern"
+  flags: RegExpFlags
+  value: Disjunction
+}
+
+export interface RegExpFlags extends IRegExpAST {
+  type: "Flags"
+  global: boolean
+  ignoreCase: boolean
+  multiLine: boolean
+  unicode: boolean
+  sticky: boolean
+}
+
+export interface Disjunction extends IRegExpAST {
+  type: "Disjunction"
+  value: Alternative[]
+}
+
+export interface Alternative extends IRegExpAST {
+  type: "Alternative"
+  value: Term[]
+}
+
+export type Term = Atom | Assertion
+
+export interface Assertion extends IRegExpAST {
+  type:
+    | "StartAnchor"
+    | "EndAnchor"
+    | "WordBoundary"
+    | "NonWordBoundary"
+    | "Lookahead"
+    | "NegativeLookahead"
+
+  value?: Disjunction
+}
+
+export type Atom = Character | Set | Group | GroupBackReference
+
+export interface Character extends IRegExpAST {
+  type: "Character"
+  value: number
+  quantifier?: Quantifier
+}
+
+export type Range = { from: number; to: number }
+
+export interface Set extends IRegExpAST {
+  type: "Set"
+  complement: boolean
+  value: (number | Range)[]
+  quantifier?: Quantifier
+}
+
+export interface Group extends IRegExpAST {
+  type: "Group"
+  value: Disjunction
+  capturing: boolean
+  idx?: number
+  quantifier?: Quantifier
+}
+
+export interface GroupBackReference extends IRegExpAST {
+  type: "GroupBackReference"
+  value: number
+  quantifier?: Quantifier
+}
+
+export interface Quantifier extends IRegExpAST {
+  type: "Quantifier"
+  atLeast: number
+  atMost: number
+  greedy: boolean
+}
+
+export class BaseRegExpVisitor {
+  /**
+   * The entry point visitor method.
+   * This will dispatch to the specific visitor method.
+   */
+  visit(node: IRegExpAST): void
+
+  /**
+   * The entry point for visiting the children of a node.
+   * Override this to filter the types of children visited
+   * or to support new types of children in extended ASTs.
+   */
+  visitChildren(node: IRegExpAST): void
+
+  /**
+   * The specific visitor methods
+   * Override some of these of create custom visitors.
+   */
+  visitPattern(node: RegExpPattern): void
+  visitFlags(node: RegExpFlags): void
+  visitDisjunction(node: Disjunction): void
+  visitAlternative(node: Alternative): void
+  visitStartAnchor(node: Assertion): void
+  visitEndAnchor(node: Assertion): void
+  visitWordBoundary(node: Assertion): void
+  visitNonWordBoundary(node: Assertion): void
+  visitLookahead(node: Assertion): void
+  visitNegativeLookahead(node: Assertion): void
+  visitCharacter(node: Character): void
+  visitSet(node: Set): void
+  visitGroup(Node: Group): void
+  visitGroupBackReference(Node: GroupBackReference): void
+  visitQuantifier(Node: Quantifier): void
+}

packages/regexp-to-ast/nyc.config.js

@@ -0,0 +1 @@
+module.exports = require("../nyc.config")

packages/regexp-to-ast/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@chevrotain/regexp-to-ast",
+  "version": "10.5.0",
+  "description": "Parses a Regular Expression and outputs an AST",
+  "keywords": [
+    "regExp",
+    "parser",
+    "regular expression"
+  ],
+  "bugs": {
+    "url": "https://github.com/Chevrotain/chevrotain/issues"
+  },
+  "exports": {
+    ".": "./lib/src/api.js"
+  },
+  "license": "Apache-2.0",
+  "typings": "api.d.ts",
+  "main": "lib/src/api.js",
+  "files": [
+    "src/**/*.ts",
+    "lib/src/**/*.js",
+    "lib/src/**/*.d.ts",
+    "lib/src/**/*.js.map",
+    "api.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Chevrotain/chevrotain.git"
+  },
+  "scripts": {
+    "---------- CI FLOWS --------": "",
+    "ci": "pnpm run build test",
+    "build": "npm-run-all clean compile",
+    "test": "npm-run-all coverage",
+    "---------- BUILD STEPS --------": "",
+    "clean": "shx rm -rf lib coverage",
+    "compile:watch": "tsc -w",
+    "compile": "tsc",
+    "coverage": "nyc mocha"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/regexp-to-ast/src/api.ts

@@ -0,0 +1,2 @@
+export { RegExpParser } from "./regexp-parser"
+export { BaseRegExpVisitor } from "./base-regexp-visitor"

packages/regexp-to-ast/src/base-regexp-visitor.ts

@@ -0,0 +1,116 @@
+import {
+  Alternative,
+  Assertion,
+  Character,
+  Disjunction,
+  Group,
+  GroupBackReference,
+  IRegExpAST,
+  Quantifier,
+  RegExpAstPart,
+  RegExpFlags,
+  RegExpPattern,
+  Set
+} from "../api"
+
+export class BaseRegExpVisitor {
+  public visitChildren(node: IRegExpAST) {
+    for (const key in node) {
+      const child = (node as any)[key]
+      /* istanbul ignore else */
+      if (node.hasOwnProperty(key)) {
+        if (child.type !== undefined) {
+          this.visit(child)
+        } else if (Array.isArray(child)) {
+          child.forEach((subChild) => {
+            this.visit(subChild)
+          }, this)
+        }
+      }
+    }
+  }
+
+  public visit(node: RegExpAstPart): void {
+    switch (node.type) {
+      case "Pattern":
+        this.visitPattern(node)
+        break
+      case "Flags":
+        this.visitFlags(node)
+        break
+      case "Disjunction":
+        this.visitDisjunction(node)
+        break
+      case "Alternative":
+        this.visitAlternative(node)
+        break
+      case "StartAnchor":
+        this.visitStartAnchor(node)
+        break
+      case "EndAnchor":
+        this.visitEndAnchor(node)
+        break
+      case "WordBoundary":
+        this.visitWordBoundary(node)
+        break
+      case "NonWordBoundary":
+        this.visitNonWordBoundary(node)
+        break
+      case "Lookahead":
+        this.visitLookahead(node)
+        break
+      case "NegativeLookahead":
+        this.visitNegativeLookahead(node)
+        break
+      case "Character":
+        this.visitCharacter(node)
+        break
+      case "Set":
+        this.visitSet(node)
+        break
+      case "Group":
+        this.visitGroup(node)
+        break
+      case "GroupBackReference":
+        this.visitGroupBackReference(node)
+        break
+      case "Quantifier":
+        this.visitQuantifier(node)
+        break
+    }
+
+    this.visitChildren(node)
+  }
+
+  public visitPattern(node: RegExpPattern): void {}
+
+  public visitFlags(node: RegExpFlags): void {}
+
+  public visitDisjunction(node: Disjunction): void {}
+
+  public visitAlternative(node: Alternative): void {}
+
+  // Assertion
+  public visitStartAnchor(node: Assertion): void {}
+
+  public visitEndAnchor(node: Assertion): void {}
+
+  public visitWordBoundary(node: Assertion): void {}
+
+  public visitNonWordBoundary(node: Assertion): void {}
+
+  public visitLookahead(node: Assertion): void {}
+
+  public visitNegativeLookahead(node: Assertion): void {}
+
+  // atoms
+  public visitCharacter(node: Character): void {}
+
+  public visitSet(node: Set): void {}
+
+  public visitGroup(node: Group): void {}
+
+  public visitGroupBackReference(node: GroupBackReference): void {}
+
+  public visitQuantifier(node: Quantifier): void {}
+}