@bcts/dcbor-pattern 1.0.0-alpha.11

package/src/parse/meta/capture-parser.ts

@@ -0,0 +1,56 @@
+/**
+ * Capture pattern parser.
+ *
+ * @module parse/meta/capture-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { capture } from "../../pattern";
+import { parseOr } from "./or-parser";
+
+/**
+ * Parse a capture pattern of the form `@name(pattern)`.
+ */
+export const parseCapture = (lexer: Lexer, name: string): Result<Pattern> => {
+  // Expect opening parenthesis
+  const openResult = lexer.next();
+  if (openResult === undefined) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+  if (!openResult.ok) {
+    return openResult;
+  }
+  if (openResult.value.token.type !== "ParenOpen") {
+    return Err({
+      type: "UnexpectedToken",
+      token: openResult.value.token,
+      span: openResult.value.span,
+    });
+  }
+
+  // Parse the inner pattern
+  const innerResult = parseOr(lexer);
+  if (!innerResult.ok) {
+    return innerResult;
+  }
+
+  // Expect closing parenthesis
+  const closeResult = lexer.next();
+  if (closeResult === undefined) {
+    return Err({ type: "ExpectedCloseParen", span: lexer.span() });
+  }
+  if (!closeResult.ok) {
+    return closeResult;
+  }
+  if (closeResult.value.token.type !== "ParenClose") {
+    return Err({
+      type: "ExpectedCloseParen",
+      span: closeResult.value.span,
+    });
+  }
+
+  return Ok(capture(name, innerResult.value));
+};

package/src/parse/meta/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Meta parsers for dCBOR patterns.
+ *
+ * @module parse/meta
+ */
+
+export * from "./or-parser";
+export * from "./and-parser";
+export * from "./not-parser";
+export * from "./repeat-parser";
+export * from "./primary-parser";
+export * from "./capture-parser";
+export * from "./search-parser";

package/src/parse/meta/not-parser.ts

@@ -0,0 +1,28 @@
+/**
+ * NOT pattern parser.
+ *
+ * @module parse/meta/not-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { not } from "../../pattern";
+import { parsePrimary } from "./primary-parser";
+
+/**
+ * Parse a NOT pattern or delegate to primary parser.
+ */
+export const parseNot = (lexer: Lexer): Result<Pattern> => {
+  const peeked = lexer.peekToken();
+  if (peeked !== undefined && peeked.ok && peeked.value.type === "Not") {
+    lexer.next(); // consume the NOT token
+    const inner = parseNot(lexer); // right associative recursion
+    if (!inner.ok) {
+      return inner;
+    }
+    return Ok(not(inner.value));
+  }
+  return parsePrimary(lexer);
+};

package/src/parse/meta/or-parser.ts

@@ -0,0 +1,47 @@
+/**
+ * OR pattern parser - the top-level pattern parser.
+ *
+ * @module parse/meta/or-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { or } from "../../pattern";
+import { parseAnd } from "./and-parser";
+
+/**
+ * Parse an OR pattern - the top-level pattern parser.
+ */
+export const parseOr = (lexer: Lexer): Result<Pattern> => {
+  const patterns: Pattern[] = [];
+  const first = parseAnd(lexer);
+  if (!first.ok) {
+    return first;
+  }
+  patterns.push(first.value);
+
+  while (true) {
+    const peeked = lexer.peekToken();
+    if (peeked?.ok !== true) {
+      break;
+    }
+    if (peeked.value.type !== "Or") {
+      break;
+    }
+    lexer.next(); // consume the OR token
+
+    const next = parseAnd(lexer);
+    if (!next.ok) {
+      return next;
+    }
+    patterns.push(next.value);
+  }
+
+  if (patterns.length === 1) {
+    return Ok(patterns[0]);
+  }
+
+  return Ok(or(...patterns));
+};

package/src/parse/meta/primary-parser.ts

@@ -0,0 +1,420 @@
+/**
+ * Primary pattern parser - handles atomic patterns.
+ *
+ * @module parse/meta/primary-parser
+ */
+
+import { CborDate } from "@bcts/dcbor";
+import { Digest } from "@bcts/components";
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { any, anyArray, anyMap, text, textRegex, number, numberRange } from "../../pattern";
+import { parseBool, parseBoolTrue, parseBoolFalse } from "../value/bool-parser";
+import { parseNull } from "../value/null-parser";
+import { parseNumber } from "../value/number-parser";
+import { parseText } from "../value/text-parser";
+import {
+  parseByteString,
+  parseHexStringToken,
+  parseHexRegexToken,
+} from "../value/bytestring-parser";
+import { parseDate } from "../value/date-parser";
+import { parseDigest } from "../value/digest-parser";
+import { parseKnownValue } from "../value/known-value-parser";
+import { parseTagged } from "../structure/tagged-parser";
+import { parseBracketArray } from "../structure/array-parser";
+import { parseBracketMap } from "../structure/map-parser";
+import { parseCapture } from "./capture-parser";
+import { parseSearch } from "./search-parser";
+import { parseQuantifier } from "./repeat-parser";
+import { parseOr } from "./or-parser";
+import { mapPatternWithLengthInterval } from "../../pattern/structure/map-pattern";
+import {
+  numberPatternNaN,
+  numberPatternInfinity,
+  numberPatternNegInfinity,
+  numberPatternGreaterThanOrEqual,
+  numberPatternLessThanOrEqual,
+  numberPatternGreaterThan,
+  numberPatternLessThan,
+} from "../../pattern/value/number-pattern";
+import { KnownValue } from "@bcts/known-values";
+import {
+  knownValuePatternValue,
+  knownValuePatternNamed,
+  knownValuePatternRegex,
+} from "../../pattern/value/known-value-pattern";
+
+/**
+ * Parse a primary pattern - the most basic unit of pattern matching.
+ */
+export const parsePrimary = (lexer: Lexer): Result<Pattern> => {
+  const tokenResult = lexer.next();
+
+  if (tokenResult === undefined) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+
+  if (!tokenResult.ok) {
+    return tokenResult;
+  }
+
+  const spanned = tokenResult.value;
+  const token = spanned.token;
+
+  switch (token.type) {
+    // Meta patterns
+    case "RepeatZeroOrMore":
+      // '*' as standalone pattern means "any"
+      return Ok(any());
+
+    case "Search":
+      return parseSearch(lexer);
+
+    // Parenthesized groups
+    case "ParenOpen": {
+      const patternResult = parseOr(lexer);
+      if (!patternResult.ok) {
+        return patternResult;
+      }
+
+      const closeResult = lexer.next();
+      if (closeResult === undefined) {
+        return Err({ type: "ExpectedCloseParen", span: lexer.span() });
+      }
+      if (!closeResult.ok) {
+        return closeResult;
+      }
+      if (closeResult.value.token.type !== "ParenClose") {
+        return Err({
+          type: "ExpectedCloseParen",
+          span: closeResult.value.span,
+        });
+      }
+
+      // After closing parenthesis, check for quantifiers
+      return parseQuantifier(patternResult.value, lexer, true);
+    }
+
+    // Capture patterns (@name(...))
+    case "GroupName":
+      return parseCapture(lexer, token.name);
+
+    // Value patterns
+    case "Bool":
+      return parseBool(lexer);
+    case "BoolTrue":
+      return parseBoolTrue(lexer);
+    case "BoolFalse":
+      return parseBoolFalse(lexer);
+    case "ByteString":
+      return parseByteString(lexer);
+    case "Date":
+      return parseDate(lexer);
+    case "Digest":
+      return parseDigest(lexer);
+    case "DigestQuoted":
+      try {
+        const digest = Digest.fromHex(token.value);
+        return Ok({
+          kind: "Value",
+          pattern: { type: "Digest", pattern: { variant: "Value", value: digest } },
+        });
+      } catch {
+        return Err({
+          type: "InvalidDigest",
+          span: spanned.span,
+        });
+      }
+    case "DateQuoted":
+      try {
+        const date = CborDate.fromString(token.value);
+        return Ok({
+          kind: "Value",
+          pattern: { type: "Date", pattern: { variant: "Value", value: date } },
+        });
+      } catch {
+        return Err({
+          type: "InvalidDate",
+          span: spanned.span,
+        });
+      }
+    case "Known":
+      return parseKnownValue(lexer);
+    case "Null":
+      return parseNull(lexer);
+    case "Number":
+      return parseNumber(lexer);
+    case "Text":
+      return parseText(lexer);
+
+    // Direct string literal
+    case "StringLiteral":
+      return Ok(text(token.value));
+
+    // Single-quoted pattern (non-prefixed known value)
+    case "SingleQuoted":
+      return parseSingleQuotedAsKnownValue(token.value);
+
+    // Direct regex literal
+    case "Regex":
+      try {
+        const regex = new RegExp(token.pattern);
+        return Ok(textRegex(regex));
+      } catch {
+        return Err({
+          type: "InvalidRegex",
+          span: spanned.span,
+        });
+      }
+
+    // Direct hex string literal
+    case "HexString":
+      return parseHexStringToken(Ok(token.value));
+
+    // Direct hex regex literal
+    case "HexRegex":
+      try {
+        const regex = new RegExp(token.pattern);
+        return parseHexRegexToken(Ok(regex));
+      } catch {
+        return Err({
+          type: "InvalidRegex",
+          span: spanned.span,
+        });
+      }
+
+    // Structure patterns
+    case "Tagged":
+      return parseTagged(lexer);
+
+    case "Array":
+      return Ok(anyArray());
+
+    case "Map":
+      return Ok(anyMap());
+
+    // Bracket syntax for arrays
+    case "BracketOpen":
+      return parseBracketArray(lexer);
+
+    // Brace syntax for maps
+    case "BraceOpen":
+      return parseBracketMap(lexer);
+
+    // Range tokens that represent map length constraints
+    case "Range":
+      return Ok({
+        kind: "Structure",
+        pattern: {
+          type: "Map",
+          pattern: mapPatternWithLengthInterval(token.quantifier.interval()),
+        },
+      });
+
+    // Number literal
+    case "NumberLiteral": {
+      // Look ahead for range operator
+      const peeked = lexer.peekToken();
+      if (peeked !== undefined && peeked.ok && peeked.value.type === "Ellipsis") {
+        lexer.next(); // consume the ellipsis
+        const endResult = lexer.next();
+        if (endResult === undefined) {
+          return Err({ type: "UnexpectedEndOfInput" });
+        }
+        if (!endResult.ok) {
+          return endResult;
+        }
+        if (endResult.value.token.type !== "NumberLiteral") {
+          return Err({
+            type: "UnexpectedToken",
+            token: endResult.value.token,
+            span: endResult.value.span,
+          });
+        }
+        return Ok(numberRange(token.value, endResult.value.token.value));
+      }
+      return Ok(number(token.value));
+    }
+
+    case "NaN":
+      return Ok({
+        kind: "Value",
+        pattern: { type: "Number", pattern: numberPatternNaN() },
+      });
+
+    case "Infinity":
+      return Ok({
+        kind: "Value",
+        pattern: { type: "Number", pattern: numberPatternInfinity() },
+      });
+
+    case "NegInfinity":
+      return Ok({
+        kind: "Value",
+        pattern: { type: "Number", pattern: numberPatternNegInfinity() },
+      });
+
+    case "GreaterThanOrEqual": {
+      const numResult = lexer.next();
+      if (numResult === undefined) {
+        return Err({ type: "UnexpectedEndOfInput" });
+      }
+      if (!numResult.ok) {
+        return numResult;
+      }
+      if (numResult.value.token.type !== "NumberLiteral") {
+        return Err({
+          type: "UnexpectedToken",
+          token: numResult.value.token,
+          span: numResult.value.span,
+        });
+      }
+      return Ok({
+        kind: "Value",
+        pattern: {
+          type: "Number",
+          pattern: numberPatternGreaterThanOrEqual(numResult.value.token.value),
+        },
+      });
+    }
+
+    case "LessThanOrEqual": {
+      const numResult = lexer.next();
+      if (numResult === undefined) {
+        return Err({ type: "UnexpectedEndOfInput" });
+      }
+      if (!numResult.ok) {
+        return numResult;
+      }
+      if (numResult.value.token.type !== "NumberLiteral") {
+        return Err({
+          type: "UnexpectedToken",
+          token: numResult.value.token,
+          span: numResult.value.span,
+        });
+      }
+      return Ok({
+        kind: "Value",
+        pattern: {
+          type: "Number",
+          pattern: numberPatternLessThanOrEqual(numResult.value.token.value),
+        },
+      });
+    }
+
+    case "GreaterThan": {
+      const numResult = lexer.next();
+      if (numResult === undefined) {
+        return Err({ type: "UnexpectedEndOfInput" });
+      }
+      if (!numResult.ok) {
+        return numResult;
+      }
+      if (numResult.value.token.type !== "NumberLiteral") {
+        return Err({
+          type: "UnexpectedToken",
+          token: numResult.value.token,
+          span: numResult.value.span,
+        });
+      }
+      return Ok({
+        kind: "Value",
+        pattern: {
+          type: "Number",
+          pattern: numberPatternGreaterThan(numResult.value.token.value),
+        },
+      });
+    }
+
+    case "LessThan": {
+      const numResult = lexer.next();
+      if (numResult === undefined) {
+        return Err({ type: "UnexpectedEndOfInput" });
+      }
+      if (!numResult.ok) {
+        return numResult;
+      }
+      if (numResult.value.token.type !== "NumberLiteral") {
+        return Err({
+          type: "UnexpectedToken",
+          token: numResult.value.token,
+          span: numResult.value.span,
+        });
+      }
+      return Ok({
+        kind: "Value",
+        pattern: {
+          type: "Number",
+          pattern: numberPatternLessThan(numResult.value.token.value),
+        },
+      });
+    }
+
+    // Unexpected tokens - these token types are not valid as primary patterns
+    case "And":
+    case "Or":
+    case "Not":
+    case "RepeatZeroOrMoreLazy":
+    case "RepeatZeroOrMorePossessive":
+    case "RepeatOneOrMore":
+    case "RepeatOneOrMoreLazy":
+    case "RepeatOneOrMorePossessive":
+    case "RepeatZeroOrOne":
+    case "RepeatZeroOrOneLazy":
+    case "RepeatZeroOrOnePossessive":
+    case "ParenClose":
+    case "BracketClose":
+    case "BraceClose":
+    case "Comma":
+    case "Colon":
+    case "Ellipsis":
+      return Err({
+        type: "UnexpectedToken",
+        token,
+        span: spanned.span,
+      });
+  }
+};
+
+/**
+ * Parse a single-quoted pattern as a known value.
+ *
+ * This handles the non-prefixed single-quoted syntax:
+ * - 'value' -> known value by numeric ID
+ * - 'name' -> known value by name
+ * - '/regex/' -> known value by regex
+ */
+const parseSingleQuotedAsKnownValue = (value: string): Result<Pattern> => {
+  // Check if it's a regex pattern (starts and ends with /)
+  if (value.startsWith("/") && value.endsWith("/") && value.length > 2) {
+    const regexStr = value.slice(1, -1);
+    try {
+      const regex = new RegExp(regexStr);
+      return Ok({
+        kind: "Value",
+        pattern: { type: "KnownValue", pattern: knownValuePatternRegex(regex) },
+      });
+    } catch {
+      return Err({ type: "InvalidRegex", span: { start: 0, end: value.length } });
+    }
+  }
+
+  // Try to parse as numeric ID
+  const numericValue = parseInt(value, 10);
+  if (!isNaN(numericValue) && numericValue.toString() === value && numericValue >= 0) {
+    const knownValue = new KnownValue(BigInt(numericValue));
+    return Ok({
+      kind: "Value",
+      pattern: { type: "KnownValue", pattern: knownValuePatternValue(knownValue) },
+    });
+  }
+
+  // Otherwise treat as name
+  return Ok({
+    kind: "Value",
+    pattern: { type: "KnownValue", pattern: knownValuePatternNamed(value) },
+  });
+};

package/src/parse/meta/repeat-parser.ts

@@ -0,0 +1,133 @@
+/**
+ * Repeat pattern parser (quantifiers).
+ *
+ * @module parse/meta/repeat-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { Quantifier } from "../../quantifier";
+import { Reluctance } from "../../reluctance";
+import { repeatPattern } from "../../pattern/meta/repeat-pattern";
+
+/**
+ * Parse quantifier tokens that follow a grouped pattern.
+ */
+export const parseQuantifier = (
+  pattern: Pattern,
+  lexer: Lexer,
+  forceRepeat: boolean,
+): Result<Pattern> => {
+  const peeked = lexer.peekToken();
+
+  if (peeked?.ok !== true) {
+    // No quantifier found
+    if (forceRepeat) {
+      return Ok(wrapInRepeat(pattern, Quantifier.exactly(1)));
+    }
+    return Ok(pattern);
+  }
+
+  const token = peeked.value;
+
+  switch (token.type) {
+    case "RepeatZeroOrMore":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore()));
+
+    case "RepeatZeroOrMoreLazy":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore(Reluctance.Lazy)));
+
+    case "RepeatZeroOrMorePossessive":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore(Reluctance.Possessive)));
+
+    case "RepeatOneOrMore":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore()));
+
+    case "RepeatOneOrMoreLazy":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore(Reluctance.Lazy)));
+
+    case "RepeatOneOrMorePossessive":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore(Reluctance.Possessive)));
+
+    case "RepeatZeroOrOne":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne()));
+
+    case "RepeatZeroOrOneLazy":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne(Reluctance.Lazy)));
+
+    case "RepeatZeroOrOnePossessive":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne(Reluctance.Possessive)));
+
+    case "Range":
+      lexer.next();
+      return Ok(wrapInRepeat(pattern, token.quantifier));
+
+    // All other tokens - no quantifier found
+    case "And":
+    case "Or":
+    case "Not":
+    case "Tagged":
+    case "Array":
+    case "Map":
+    case "Bool":
+    case "ByteString":
+    case "Date":
+    case "Known":
+    case "Null":
+    case "Number":
+    case "Text":
+    case "Digest":
+    case "Search":
+    case "BoolTrue":
+    case "BoolFalse":
+    case "NaN":
+    case "Infinity":
+    case "NegInfinity":
+    case "ParenOpen":
+    case "ParenClose":
+    case "BracketOpen":
+    case "BracketClose":
+    case "BraceOpen":
+    case "BraceClose":
+    case "Comma":
+    case "Colon":
+    case "Ellipsis":
+    case "GreaterThanOrEqual":
+    case "LessThanOrEqual":
+    case "GreaterThan":
+    case "LessThan":
+    case "NumberLiteral":
+    case "GroupName":
+    case "StringLiteral":
+    case "SingleQuoted":
+    case "Regex":
+    case "HexString":
+    case "HexRegex":
+    case "DateQuoted":
+    case "DigestQuoted":
+      // No quantifier found
+      if (forceRepeat) {
+        return Ok(wrapInRepeat(pattern, Quantifier.exactly(1)));
+      }
+      return Ok(pattern);
+  }
+};
+
+/**
+ * Wrap a pattern in a RepeatPattern with the given quantifier.
+ */
+const wrapInRepeat = (pattern: Pattern, quantifier: Quantifier): Pattern => ({
+  kind: "Meta",
+  pattern: { type: "Repeat", pattern: repeatPattern(pattern, quantifier) },
+});