store

Author: curtisman

ts/packages/actionGrammar/src/grammarCompiler.ts

@@ -1,50 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { Rule, RuleDefinition, ValueNode } from "./grammarParser.js";
-
-type StringPart = {
-    type: "string";
-
-    value: string[];
-
-    /* TODO: cache the regexp?
-    regexp?: RegExp;
-    regexpWithPendingWildcards?: RegExp;
-    */
-};
-
-type VarStringPart = {
-    type: "wildcard";
-    variable: string;
-
-    typeName: string; // Do we need this?
-};
-
-type VarNumberPart = {
-    type: "number";
-    variable: string;
-};
-
-type RulesPart = {
-    type: "rules";
-
-    rules: GrammarRule[];
-    name?: string; // Do we need this?
-
-    variable?: string;
-    optional?: boolean | undefined;
-};
-
-type GrammarPart = StringPart | VarStringPart | VarNumberPart | RulesPart;
-export type GrammarRule = {
-    parts: GrammarPart[];
-    value?: ValueNode | undefined;
-};
-
-export type Grammar = {
-    rules: GrammarRule[];
-};
+import {
+    Grammar,
+    GrammarPart,
+    GrammarRule,
+    StringPart,
+} from "./grammarTypes.js";
+import { Rule, RuleDefinition } from "./grammarRuleParser.js";
 
 type DefinitionMap = Map<
     string,

ts/packages/actionGrammar/src/grammarDeserializer.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+    Grammar,
+    GrammarJson,
+    GrammarPart,
+    GrammarPartJson,
+    GrammarRule,
+    GrammarRuleJson,
+} from "./grammarTypes.js";
+
+export function grammarFromJson(json: GrammarJson): Grammar {
+    const start = json[0];
+    const indexToRules: Map<number, GrammarRule[]> = new Map();
+    function grammarRuleFromJson(r: GrammarRuleJson, json: GrammarJson) {
+        return {
+            parts: r.parts.map((p) => grammarPartFromJson(p, json)),
+            value: r.value,
+        };
+    }
+    function grammarPartFromJson(
+        p: GrammarPartJson,
+        json: GrammarJson,
+    ): GrammarPart {
+        switch (p.type) {
+            case "string":
+            case "wildcard":
+            case "number":
+                return p;
+            case "rules":
+                let rules = indexToRules.get(p.index);
+                if (rules === undefined) {
+                    rules = [];
+                    indexToRules.set(p.index, rules);
+                    for (const r of json[p.index]) {
+                        rules.push(grammarRuleFromJson(r, json));
+                    }
+                }
+                return {
+                    type: "rules",
+                    name: p.name,
+                    rules,
+                    variable: p.variable,
+                    optional: p.optional,
+                };
+        }
+    }
+
+    return {
+        rules: start.map((r) => grammarRuleFromJson(r, json)),
+    };
+}

ts/packages/actionGrammar/src/grammarLoader.ts

@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { compileGrammar, Grammar } from "./grammarCompiler.js";
-import { parseGrammar } from "./grammarParser.js";
+import { compileGrammar } from "./grammarCompiler.js";
+import { parseGrammarRules } from "./grammarRuleParser.js";
+import { Grammar } from "./grammarTypes.js";
 
-export function loadGrammar(fileName: string, content: string): Grammar {
-    const definitions = parseGrammar(fileName, content);
+export function loadGrammarRules(fileName: string, content: string): Grammar {
+    const definitions = parseGrammarRules(fileName, content);
     const grammar = compileGrammar(definitions);
     return grammar;
 }

ts/packages/actionGrammar/src/grammarMatcher.ts

@@ -1,11 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { ValueNode } from "./grammarParser.js";
+import { ValueNode } from "./grammarRuleParser.js";
 import registerDebug from "debug";
 // REVIEW: switch to RegExp.escape() when it becomes available.
 import escapeMatch from "regexp.escape";
-import { Grammar, GrammarRule } from "./grammarCompiler.js";
+import { Grammar, GrammarRule } from "./grammarTypes.js";
 
 const debugMatch = registerDebug("typeagent:grammar:match");
 

ts/packages/actionGrammar/src/grammarParser.ts renamed to ts/packages/actionGrammar/src/grammarRuleParser.ts

@@ -47,11 +47,11 @@ const debugParse = registerDebug("typeagent:grammar:parse");
  *   <SingleLineComment> ::= "//" [^\n]* "\n"
  *   <MultiLineComment> ::= "/*" .* "*\/"
  */
-export function parseGrammar(
+export function parseGrammarRules(
     fileName: string,
     content: string,
 ): RuleDefinition[] {
-    const parser = new CacheGrammarParser(fileName, content);
+    const parser = new GrammarRuleParser(fileName, content);
     const definitions = parser.parse();
     debugParse(JSON.stringify(definitions, undefined, 2));
     return definitions;
@@ -146,7 +146,7 @@ export function isExpressionSpecialChar(char: string) {
     return expressionsSpecialChar.includes(char);
 }
 
-class CacheGrammarParser {
+class GrammarRuleParser {
     private curr: number = 0;
     constructor(
         private readonly fileName: string,

ts/packages/actionGrammar/src/grammarWriter.ts renamed to ts/packages/actionGrammar/src/grammarRuleWriter.ts

@@ -8,9 +8,9 @@ import {
     Rule,
     RuleDefinition,
     ValueNode,
-} from "./grammarParser.js";
+} from "./grammarRuleParser.js";
 
-export function writeGrammar(grammar: RuleDefinition[]): string {
+export function writeGrammarRules(grammar: RuleDefinition[]): string {
     const result: string[] = [];
     for (const def of grammar) {
         writeRuleDefinition(result, def);

ts/packages/actionGrammar/src/grammarSerializer.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+    Grammar,
+    GrammarJson,
+    GrammarPart,
+    GrammarPartJson,
+    GrammarRule,
+    GrammarRuleJson,
+    GrammarRules,
+} from "./grammarTypes.js";
+
+export function grammarToJson(grammar: Grammar): GrammarJson {
+    const json: GrammarRules[] = [];
+    const rulesToIndex: Map<GrammarRule[], number> = new Map();
+    let nextIndex = 1;
+
+    function grammarPartToJson(p: GrammarPart): GrammarPartJson {
+        switch (p.type) {
+            case "string":
+            case "wildcard":
+            case "number":
+                return p;
+            case "rules": {
+                let index = rulesToIndex.get(p.rules);
+                if (index === undefined) {
+                    index = nextIndex++;
+                    rulesToIndex.set(p.rules, index);
+                    json[index] = p.rules.map(grammarRuleToJson);
+                }
+
+                return {
+                    name: p.name,
+                    type: "rules",
+                    index,
+                    variable: p.variable,
+                    optional: p.optional,
+                };
+            }
+        }
+    }
+
+    function grammarRuleToJson(r: GrammarRule): GrammarRuleJson {
+        return {
+            parts: r.parts.map(grammarPartToJson),
+            value: r.value,
+        };
+    }
+
+    rulesToIndex.set(grammar.rules, 0);
+    json[0] = grammar.rules.map(grammarRuleToJson);
+    return json;
+}

ts/packages/actionGrammar/src/grammarTypes.ts

@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { ValueNode } from "./grammarRuleParser.js";
+
+/**
+ * In memory types
+ */
+export type StringPart = {
+    type: "string";
+
+    value: string[];
+
+    /* TODO: cache the regexp?
+    regexp?: RegExp;
+    regexpWithPendingWildcards?: RegExp;
+    */
+};
+
+export type VarStringPart = {
+    type: "wildcard";
+    variable: string;
+    typeName: string; // Not needed at runtime?
+};
+
+export type VarNumberPart = {
+    type: "number";
+    variable: string;
+};
+
+export type RulesPart = {
+    type: "rules";
+
+    rules: GrammarRule[];
+    name?: string | undefined; // For debugging
+
+    variable?: string | undefined;
+    optional?: boolean | undefined;
+};
+
+export type GrammarPart =
+    | StringPart
+    | VarStringPart
+    | VarNumberPart
+    | RulesPart;
+export type GrammarRule = {
+    parts: GrammarPart[];
+    value?: ValueNode | undefined;
+};
+
+export type Grammar = {
+    rules: GrammarRule[];
+};
+
+/**
+ * Serialized types
+ */
+export type StringPartJson = {
+    type: "string";
+    value: string[];
+};
+
+export type VarStringPartJson = {
+    type: "wildcard";
+    variable: string;
+    typeName: string;
+};
+
+export type VarNumberPartJson = {
+    type: "number";
+    variable: string;
+};
+
+export type RulePartJson = {
+    type: "rules";
+    name?: string | undefined;
+    index: number;
+    variable?: string | undefined;
+    optional?: boolean | undefined;
+};
+
+export type GrammarPartJson =
+    | StringPartJson
+    | VarStringPartJson
+    | VarNumberPartJson
+    | RulePartJson;
+
+export type GrammarRuleJson = {
+    parts: GrammarPartJson[];
+    value?: ValueNode | undefined;
+};
+export type GrammarRules = GrammarRuleJson[];
+export type GrammarJson = GrammarRules[];

ts/packages/actionGrammar/src/index.ts

@@ -1,5 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-export { loadGrammar } from "./grammarLoader.js";
+export type { GrammarJson, Grammar } from "./grammarTypes.js";
+export { grammarFromJson } from "./grammarDeserializer.js";
+export { grammarToJson } from "./grammarSerializer.js";
+export { loadGrammarRules } from "./grammarLoader.js";
 export { matchGrammar } from "./grammarMatcher.js";

ts/packages/actionGrammar/src/indexRules.ts

@@ -1,5 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-export { ValueNode, Expr, Rule, RuleDefinition } from "./grammarParser.js";
-export { writeGrammar } from "./grammarWriter.js";
+export { ValueNode, Expr, Rule, RuleDefinition } from "./grammarRuleParser.js";
+export { writeGrammarRules } from "./grammarRuleWriter.js";