feat: conditional rules in the language grammars

packages/keybr-code/lib/ast.ts

@@ -7,7 +7,13 @@ export type HasCodePoints = {
   codePoints?: ReadonlySet<number>;
 };
 
-export type Prod = Span | Opt | Seq | Alt | Ref | string;
+export type Prod = Cond | Span | Opt | Seq | Alt | Ref | string;
+
+export type Cond = HasCodePoints & {
+  readonly flag: string;
+  readonly inv: boolean;
+  readonly cond: Prod;
+};
 
 export type Span = HasCodePoints & {
   readonly cls: string;
@@ -31,6 +37,10 @@ export type Ref = HasCodePoints & {
   readonly ref: string;
 };
 
+export function isCond(v: Prod): v is Cond {
+  return typeof v === "object" && "cond" in v;
+}
+
 export function isSpan(v: Prod): v is Span {
   return typeof v === "object" && "span" in v;
 }

packages/keybr-code/lib/compile.ts

@@ -2,14 +2,12 @@
 
 import { readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
-import { compiler } from "peggy";
+import peggy from "peggy";
 import { optimize } from "./optimize.ts";
 import { parse } from "./parse.ts";
 import { validate } from "./validate.ts";
 
-if (compiler == null) {
-  /* Suppress the unused dependency warning. */
-}
+console.log(`Peggy version: ${peggy.VERSION}`);
 
 export const rootDir = resolve(import.meta.dirname, "..");
 

packages/keybr-code/lib/example.ts

@@ -1,13 +1,14 @@
 #!/usr/bin/env -S node --import @keybr/tsl
 
 import { LCG } from "@keybr/rand";
+import { flagSet } from "./flags.ts";
 import { Syntax } from "./syntax.ts";
 
 for (const syntax of Syntax.ALL) {
-  console.log(`=== ${syntax.name} ===`);
+  console.log(`=== ${syntax.name} (${[...syntax.flags].join(",")}) ===`);
   const rng = LCG(1);
   for (let i = 0; i < 5; i++) {
-    console.log(syntax.generate(rng));
+    console.log(syntax.generate(flagSet(["*"]), rng));
   }
   console.log();
 }

packages/keybr-code/lib/find-flags.test.ts

@@ -0,0 +1,12 @@
+import test from "ava";
+import { findFlags } from "./find-flags.ts";
+import { parse } from "./parse.ts";
+
+test("find flags", (t) => {
+  const rules = parse(
+    `a -> { :if(f1) "a" { :if(f2) "b" | { :if(f3) "c" } } };\n` +
+      `b -> "..." { :class(c1) { :if(xyz) "1" | "2" | "3" } } "...";\n`,
+  );
+  const flags = findFlags(rules);
+  t.deepEqual(flags, new Set(["f1", "f2", "f3", "xyz"]));
+});

packages/keybr-code/lib/find-flags.ts

@@ -0,0 +1,49 @@
+import {
+  isAlt,
+  isCond,
+  isOpt,
+  isSeq,
+  isSpan,
+  type Prod,
+  type Rules,
+} from "./ast.ts";
+
+export function findFlags(rules: Rules): Set<string> {
+  const flags = new Set<string>();
+  for (const rule of Object.values(rules)) {
+    visit(rule);
+  }
+  return flags;
+
+  function visit(p: Prod): void {
+    if (isCond(p)) {
+      flags.add(p.flag);
+      visit(p.cond);
+      return;
+    }
+
+    if (isSpan(p)) {
+      visit(p.span);
+      return;
+    }
+
+    if (isOpt(p)) {
+      visit(p.opt);
+      return;
+    }
+
+    if (isSeq(p)) {
+      for (const child of p.seq) {
+        visit(child);
+      }
+      return;
+    }
+
+    if (isAlt(p)) {
+      for (const child of p.alt) {
+        visit(child);
+      }
+      return;
+    }
+  }
+}

packages/keybr-code/lib/flags.ts

@@ -0,0 +1,12 @@
+export type Flags = {
+  has(flag: string): boolean;
+};
+
+export function flagSet(flags: readonly string[] | ReadonlySet<string>): Flags {
+  const set = new Set(flags);
+  return {
+    has(flag) {
+      return set.has(flag) || set.has("*");
+    },
+  };
+}

packages/keybr-code/lib/generate.ts

@@ -1,6 +1,7 @@
 import { LCG, type RNG } from "@keybr/rand";
 import {
   isAlt,
+  isCond,
   isLit,
   isOpt,
   isRef,
@@ -9,6 +10,7 @@ import {
   type Prod,
   type Rules,
 } from "./ast.ts";
+import { type Flags, flagSet } from "./flags.ts";
 import { Output } from "./output.ts";
 
 const lcg = LCG(1);
@@ -18,11 +20,14 @@ const lcg = LCG(1);
  */
 export function generate(
   rules: Rules,
-  start: string = "start",
   {
+    start = "start",
+    flags = flagSet(["*"]),
     output = new Output(),
     rng = lcg,
   }: {
+    readonly start?: string;
+    readonly flags?: Flags;
     readonly output?: Output;
     readonly rng?: RNG;
   } = {},
@@ -32,6 +37,13 @@ export function generate(
   return String(output);
 
   function visit(p: Prod): void {
+    if (isCond(p)) {
+      if (flags.has(p.flag) !== p.inv) {
+        visit(p.cond);
+      }
+      return;
+    }
+
     if (isSpan(p)) {
       visit(p.span);
       return;

packages/keybr-code/lib/index.ts

@@ -1,2 +1,3 @@
+export * from "./flags.ts";
 export * from "./generate.ts";
 export * from "./syntax.ts";

packages/keybr-code/lib/optimize.ts

@@ -1,6 +1,8 @@
 import {
   type Alt,
+  type Cond,
   isAlt,
+  isCond,
   isLit,
   isOpt,
   isSeq,
@@ -29,6 +31,10 @@ export function optimize(rules: Rules): Rules {
 }
 
 function visit(p: Prod): Prod {
+  if (isCond(p)) {
+    return visitCond(p);
+  }
+
   if (isSpan(p)) {
     return visitSpan(p);
   }
@@ -48,13 +54,15 @@ function visit(p: Prod): Prod {
   return p;
 }
 
-function visitSpan(v: Span): Prod {
-  const { cls, span } = v;
+function visitCond({ cond, flag, inv }: Cond): Prod {
+  return { flag, inv, cond: visit(cond) };
+}
+
+function visitSpan({ span, cls }: Span): Prod {
   return { cls, span: visit(span) };
 }
 
-function visitOpt(v: Opt): Prod {
-  const { f, opt } = v;
+function visitOpt({ f, opt }: Opt): Prod {
   if (f === 1) {
     return visit(opt);
   } else {

packages/keybr-code/lib/parse.test.ts

@@ -35,6 +35,30 @@ test("parse alt", (t) => {
   });
 });
 
+test("parse cond", (t) => {
+  t.deepEqual(parse(`start -> { :if(f1) "a" "b" "c" };`), {
+    start: { flag: "f1", inv: false, cond: { seq: ["a", "b", "c"] } },
+  });
+  t.deepEqual(parse(`start -> { :if(f1) "a" | "b" | "c" };`), {
+    start: { flag: "f1", inv: false, cond: { alt: ["a", "b", "c"] } },
+  });
+  t.deepEqual(parse(`start -> { :if(!f1) "a" "b" "c" };`), {
+    start: { flag: "f1", inv: true, cond: { seq: ["a", "b", "c"] } },
+  });
+  t.deepEqual(parse(`start -> { :if(!f1) "a" | "b" | "c" };`), {
+    start: { flag: "f1", inv: true, cond: { alt: ["a", "b", "c"] } },
+  });
+});
+
+test("parse span", (t) => {
+  t.deepEqual(parse(`start -> { :class(c1) "a" "b" "c" };`), {
+    start: { cls: "c1", span: { seq: ["a", "b", "c"] } },
+  });
+  t.deepEqual(parse(`start -> { :class(c1) "a" | "b" | "c" };`), {
+    start: { cls: "c1", span: { alt: ["a", "b", "c"] } },
+  });
+});
+
 test("priorities", (t) => {
   t.deepEqual(parse(`start -> ("a" | "b") "c";`), {
     start: { seq: [{ alt: ["a", "b"] }, "c"] },
@@ -70,8 +94,6 @@ test("syntax error", (t) => {
     },
     {
       name: "SyntaxError",
-      message:
-        'Expected "(", "[", literal, ref, separator, or whitespace but end of input found.',
     },
   ) as SyntaxError;
   t.deepEqual(location, {