e2e

Author: curtisman

ts/packages/actionGrammar/src/grammarMatcher.ts

@@ -28,6 +28,7 @@ type MatchedValue =
 type MatchedValueNode = {
     valueId: number;
     value: MatchedValue;
+    wildcard: boolean;
     prev: MatchedValueNode | undefined;
 };
 
@@ -64,22 +65,35 @@ type MatchState = {
         | undefined;
 };
 
-function getMatchedValue(
-    valueId: ValueIdNode,
+function getMatchedValueNode(
+    valueId: number,
     values: MatchedValueNode | undefined,
-): MatchedValue | undefined {
+): MatchedValueNode {
     let v: MatchedValueNode | undefined = values;
-    while (v !== undefined && v.valueId !== valueId.valueId) {
+    while (v !== undefined && v.valueId !== valueId) {
         v = v.prev;
     }
-    return v?.value;
+    if (v === undefined) {
+        throw new Error(`Internal error: Missing value for ${valueId}`);
+    }
+    return v;
 }
 
+type GrammarMatchStat = {
+    matchedValueCount: number;
+    wildcardCharCount: number;
+    entityWildcardPropertyNames: string[];
+};
+export type GrammarMatchResult = GrammarMatchStat & {
+    match: unknown;
+};
+
 function createValue(
+    stat: GrammarMatchStat,
     node: ValueNode | undefined,
     valueIds: ValueIdNode | undefined,
     values: MatchedValueNode | undefined,
-): any {
+): unknown {
     if (node === undefined) {
         if (valueIds === undefined) {
             throw new Error("Internal error: default matched values");
@@ -89,9 +103,10 @@ function createValue(
                 `Internal error: No value definitions for multiple values`,
             );
         }
-        const value = getMatchedValue(valueIds, values);
+        const valueNode = getMatchedValueNode(valueIds.valueId, values);
+        const value = valueNode.value;
         if (typeof value === "object") {
-            return createValue(value.node, value.valueIds, values);
+            return createValue(stat, value.node, value.valueIds, values);
         }
         return value;
     }
@@ -103,14 +118,14 @@ function createValue(
             const obj: Record<string, any> = {};
 
             for (const [k, v] of Object.entries(node.value)) {
-                obj[k] = createValue(v, valueIds, values);
+                obj[k] = createValue(stat, v, valueIds, values);
             }
             return obj;
         }
         case "array": {
             const arr: any[] = [];
             for (const v of node.value) {
-                arr.push(createValue(v, valueIds, values));
+                arr.push(createValue(stat, v, valueIds, values));
             }
             return arr;
         }
@@ -124,10 +139,26 @@ function createValue(
                     `Internal error: No value for variable '${node.name}. Values: ${JSON.stringify(valueIds)}'`,
                 );
             }
-            const value = getMatchedValue(v, values);
+            const valueNode = getMatchedValueNode(v.valueId, values);
+            const value = valueNode.value;
             if (typeof value === "object") {
-                return createValue(value.node, value.valueIds, values);
+                return createValue(stat, value.node, value.valueIds, values);
+            }
+
+            // undefined means optional, don't count
+            if (value !== undefined) {
+                stat.matchedValueCount++;
             }
+
+            if (valueNode.wildcard) {
+                if (typeof value !== "string") {
+                    throw new Error(
+                        `Internal error: Wildcard has non-string value for variable '${node.name}'`,
+                    );
+                }
+                stat.wildcardCharCount += value.length;
+            }
+
             return value;
         }
     }
@@ -157,14 +188,14 @@ function createCaptureWildcardState(
     newIndex: number,
 ) {
     const { start: wildcardStart, valueId } = state.pendingWildcard!;
-    const wildcard = captureWildcard(request, wildcardStart, wildcardEnd);
-    if (wildcard === undefined) {
+    const wildcardStr = captureWildcard(request, wildcardStart, wildcardEnd);
+    if (wildcardStr === undefined) {
         return undefined;
     }
     const newState = { ...state };
     newState.index = newIndex;
     newState.pendingWildcard = undefined;
-    addValueWithId(newState, valueId, wildcard);
+    addValueWithId(newState, valueId, wildcardStr, true);
     return newState;
 }
 
@@ -178,10 +209,12 @@ function addValueWithId(
     state: MatchState,
     valueId: number,
     matchedValue: MatchedValue,
+    wildcard: boolean,
 ) {
     state.values = {
         valueId,
         value: matchedValue,
+        wildcard,
         prev: state.values,
     };
 }
@@ -192,13 +225,13 @@ function addValue(
     matchedValue: MatchedValue,
 ) {
     const valueId = addValueId(state, name);
-    addValueWithId(state, valueId, matchedValue);
+    addValueWithId(state, valueId, matchedValue, false);
 }
 
 function finalizeRule(
     state: MatchState,
     request: string,
-    results: any[],
+    results: GrammarMatchResult[],
     pending: MatchState[],
 ) {
     const nested = state.nested;
@@ -239,7 +272,7 @@ function finalizeRule(
             return;
         }
         state.index = request.length;
-        addValueWithId(state, state.pendingWildcard.valueId, value);
+        addValueWithId(state, state.pendingWildcard.valueId, value, true);
     }
     if (state.index < request.length) {
         // Detect trailing separators
@@ -261,18 +294,34 @@ function finalizeRule(
     debugMatch(
         `Matched at end of input. Matched ids: ${JSON.stringify(state.valueIds)}, values: ${JSON.stringify(state.values)}'`,
     );
-    results.push(createValue(state.rule.value, state.valueIds, state.values));
+
+    const matchResult: GrammarMatchResult = {
+        match: undefined,
+        matchedValueCount: 0,
+        wildcardCharCount: 0,
+        entityWildcardPropertyNames: [],
+    };
+    matchResult.match = createValue(
+        matchResult,
+        state.rule.value,
+        state.valueIds,
+        state.values,
+    );
+    results.push(matchResult);
 }
 
-type MatchResult = any;
-function matchRules(grammar: Grammar, request: string): MatchResult[] {
+function matchRules(grammar: Grammar, request: string): GrammarMatchResult[] {
     const pending: MatchState[] = grammar.rules.map((r) => ({
         rule: r,
         partIndex: 0,
         index: 0,
         nextValueId: 0,
+        matchedCount: 0,
+        wildcardCharCount: 0,
+        nonOptionalCount: 0,
+        implicitParameterCount: 0,
     }));
-    const results: MatchResult[] = [];
+    const results: GrammarMatchResult[] = [];
     while (pending.length > 0) {
         const state = pending.shift()!;
         const { rule, partIndex } = state;

ts/packages/actionGrammar/src/index.ts

@@ -5,4 +5,4 @@ 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";
+export { matchGrammar, GrammarMatchResult } from "./grammarMatcher.js";