@vertekum/schema-builder 0.1.7 → 0.2.0

package/src/parser.ts

@@ -1,4 +1,4 @@
-import type { Alt, Module, ModuleMeta, Node, Path, Step } from './ast';
+import type { Alt, Module, ModuleMeta, Node, Path, Ref, Step } from './ast';
 import { DfnError } from './error';
 import { type Token, tokenize } from './tokenizer';
 
@@ -51,6 +51,8 @@ class Parser {
   module(): Module {
     const uses: Array<{ spec: string; alias?: string }> = [];
     const productions = new Map<string, Node>();
+    const privates = new Set<string>();
+    const notes: Array<{ line: number; column: number; message: string }> = [];
     const meta: ModuleMeta = {};
     let root: Node | undefined;
 
@@ -75,10 +77,11 @@ class Parser {
           name.value !== 'id' &&
           name.value !== 'title' &&
           name.value !== 'description' &&
-          name.value !== 'scope'
+          name.value !== 'scope' &&
+          name.value !== 'sealed'
         ) {
           throw new DfnError(
-            `unknown pragma '${name.value}' — id, title, description, and scope exist`,
+            `unknown pragma '${name.value}' — id, title, description, scope, and sealed exist`,
             name.line,
             name.column,
           );
@@ -92,17 +95,66 @@ class Parser {
           );
         }
         if (key === 'scope') {
-          if (value !== 'document' && value !== 'branch') {
+          if (value === 'branch') {
+            // The old sealing value, before `sealed` existed — honored, and noted for lint.
+            meta.sealed = false;
+            notes.push({
+              line: name.line,
+              column: name.column,
+              message:
+                'scope "branch" is deprecated — write sealed "false" (scope now names the file\'s nature: document, def, or inline)',
+            });
+          } else if (
+            value === 'document' ||
+            value === 'def' ||
+            value === 'inline'
+          ) {
+            meta.scope = value;
+          } else {
             throw new DfnError(
-              `scope is "document" or "branch", not "${value}"`,
+              `scope is "document", "def", or "inline", not "${value}"`,
               name.line,
               name.column,
             );
           }
-          meta.scope = value;
+        } else if (key === 'sealed') {
+          if (value !== 'true' && value !== 'false') {
+            throw new DfnError(
+              `sealed is "true" or "false", not "${value}"`,
+              name.line,
+              name.column,
+            );
+          }
+          meta.sealed = value === 'true';
         } else {
           meta[key] = value;
         }
+      } else if (
+        token.kind === 'colon' &&
+        this.at(1)?.kind === 'ident' &&
+        this.at(2)?.kind === 'equals'
+      ) {
+        // `:name = …` — a PRIVATE production: inlined at use, invisible to importers.
+        this.next();
+        const name = this.next();
+        this.next();
+        const expression = this.alternation();
+        if (name.value === 'root') {
+          throw new DfnError(
+            'root cannot be private — it is the module itself',
+            name.line,
+            name.column,
+          );
+        }
+        if (productions.has(name.value)) {
+          throw new DfnError(
+            `duplicate production '${name.value}'`,
+            name.line,
+            name.column,
+          );
+        }
+        productions.set(name.value, expression);
+        privates.add(name.value);
       } else if (token.kind === 'ident') {
         const name = this.next();
         this.expect('equals', "'='");
@@ -147,7 +199,7 @@ class Parser {
       this.skipNewlines();
     }
 
-    return { uses, productions, root, meta };
+    return { uses, productions, private: privates, root, meta, notes };
   }
 
   /** `a | b | c` — a single option collapses to itself. */
@@ -184,8 +236,27 @@ class Parser {
     return { term, optional };
   }
 
-  /** A pick/omit list member: an identifier or a (possibly padded) number. */
-  private member(): string {
+  /** A pick/omit list member: a name, a number, or a REFERENCE (its whole name set). */
+  private member(): string | Ref {
+    if (this.peek().kind === 'langle') {
+      const at = this.peek();
+      const term = this.term();
+      if (term.kind !== 'ref') {
+        throw new DfnError(
+          'expected a member name or reference',
+          at.line,
+          at.column,
+        );
+      }
+      if (term.open) {
+        throw new DfnError(
+          'a member reference names a closed set — drop the *',
+          at.line,
+          at.column,
+        );
+      }
+      return term;
+    }
     const token = this.next();
     if (token.kind !== 'ident' && token.kind !== 'number') {
       throw new DfnError(
@@ -206,7 +277,11 @@ class Parser {
         return { kind: 'name', value: token.value, ...at };
       case 'range': {
         const payload = token.range as NonNullable<Token['range']>;
-        const { min, max, mode, step, quantum, pad } = payload;
+        const { min, max, mode, step, quantum, pad, prefix, suffix } = payload;
+        const affixes = {
+          ...(prefix !== undefined ? { prefix } : {}),
+          ...(suffix !== undefined ? { suffix } : {}),
+        };
         if (max < min) {
           throw new DfnError(
             'range needs max >= min',
@@ -229,7 +304,16 @@ class Parser {
               token.column,
             );
           }
-          return { kind: 'range', min, max, mode: 'stepped', step, pad, ...at };
+          return {
+            kind: 'range',
+            min,
+            max,
+            mode: 'stepped',
+            step,
+            pad,
+            ...affixes,
+            ...at,
+          };
         }
         if (step <= 1) {
           throw new DfnError(
@@ -246,6 +330,7 @@ class Parser {
           step,
           quantum,
           pad,
+          ...affixes,
           ...at,
         };
       }
@@ -269,8 +354,8 @@ class Parser {
           name = this.expect('ident', 'a production name');
         }
         // Set modifiers: `[a, b]` picks only the listed members; `![a, b]` omits them.
-        const pick: string[] = [];
-        const omit: string[] = [];
+        const pick: Array<string | Ref> = [];
+        const omit: Array<string | Ref> = [];
         const negated = this.peek().kind === 'bang';
         if (negated) this.next();
         if (this.peek().kind === 'lbracket') {

package/src/resolve.ts

@@ -42,6 +42,8 @@ function resolveSpecifier(spec: string, fromDir: string): string {
 export function resolveModule(
   path: string,
   inProgress: Set<string> = new Set(),
+  /** In-memory source overrides by absolute path — how `lint --fix` validates before writing. */
+  sources?: Map<string, string>,
 ): ResolvedModule {
   const absolute = resolve(path);
   if (inProgress.has(absolute)) {
@@ -50,10 +52,15 @@ export function resolveModule(
   inProgress.add(absolute);
 
   let source: string;
-  try {
-    source = readFileSync(absolute, 'utf8');
-  } catch {
-    throw new DfnError(`cannot read ${absolute}`, 1, 1);
+  const override = sources?.get(absolute);
+  if (override !== undefined) {
+    source = override;
+  } else {
+    try {
+      source = readFileSync(absolute, 'utf8');
+    } catch {
+      throw new DfnError(`cannot read ${absolute}`, 1, 1);
+    }
   }
   let module: Module;
   try {
@@ -70,7 +77,7 @@ export function resolveModule(
   const imports = new Map<string, ResolvedModule>();
   for (const { spec, alias } of module.uses) {
     const target = resolveSpecifier(spec, dirname(absolute));
-    const resolved = resolveModule(target, inProgress);
+    const resolved = resolveModule(target, inProgress, sources);
     const key = alias ?? resolved.name;
     if (imports.has(key)) {
       throw new DfnError(

package/src/tokenizer.ts

@@ -26,6 +26,7 @@ export type TokenKind =
   | 'comma'
   | 'bang'
   | 'slash'
+  | 'colon'
   | 'newline'
   | 'eof';
 
@@ -42,13 +43,24 @@ export interface Token {
     quantum?: number;
     /** Pad width inferred from a leading zero on a written endpoint (`025` → 3). */
     pad?: number;
+    /** Affixes from the parenthesized form: `x(2-8/2)s` → prefix `x`, suffix `s`. */
+    prefix?: string;
+    suffix?: string;
   };
   line: number;
   column: number;
 }
 
 const IDENT = /^[A-Za-z][A-Za-z0-9-]*/;
-const RANGE = /^(\d+)-(\d+)([*/])(\d+(?:\.\d+)?)(?:~(\d+))?/;
+/** The step is optional: `2-4` is an additive scale stepped by 1. */
+const RANGE = /^(\d+)-(\d+)(?:([*/])(\d+(?:\.\d+)?))?(?:~(\d+))?/;
+/**
+ * An AFFIXED scale: word fragments hugging a parenthesized formula, as ONE term —
+ * `(2-4)xs`, `xs(2-4)`, `x(2-8/2)s`. The parentheses are what make the affix
+ * boundaries readable, so a bare range never takes affixes.
+ */
+const AFFIXED =
+  /^([A-Za-z][A-Za-z0-9-]*)?\((\d+)-(\d+)(?:([*/])(\d+(?:\.\d+)?))?(?:~(\d+))?\)([A-Za-z][A-Za-z0-9-]*)?/;
 /**
  * A digit-leading NAME (`2xs`, `4k-display`): digits, then at least one letter. Tried after
  * RANGE — so `100-300/50` stays numeric — and before NUMBER, so the whole word is one token
@@ -67,6 +79,9 @@ function padWidth(...literals: string[]): number | undefined {
 export function tokenize(source: string): Token[] {
   const tokens: Token[] = [];
   const lines = source.split('\n');
+  // Open `[` positions. A statement ends at the first newline at bracket depth 0, so while
+  // this stack is non-empty a group is a BLOCK — newlines inside it are insignificant.
+  const openBrackets: Array<{ line: number; column: number }> = [];
 
   for (let i = 0; i < lines.length; i++) {
     const line = i + 1;
@@ -99,6 +114,28 @@ export function tokenize(source: string): Token[] {
         text = text.slice(value.length);
       };
 
+      const affixed = text.match(AFFIXED);
+      if (affixed) {
+        tokens.push({
+          kind: 'range',
+          value: affixed[0],
+          range: {
+            min: Number(affixed[2]),
+            max: Number(affixed[3]),
+            mode: (affixed[4] ?? '/') as '/' | '*',
+            step: affixed[5] ? Number(affixed[5]) : 1,
+            quantum: affixed[6] ? Number(affixed[6]) : undefined,
+            pad: padWidth(affixed[2], affixed[3]),
+            prefix: affixed[1] || undefined,
+            suffix: affixed[7] || undefined,
+          },
+          line,
+          column,
+        });
+        column += affixed[0].length;
+        text = text.slice(affixed[0].length);
+        continue;
+      }
       const range = text.match(RANGE);
       if (range) {
         tokens.push({
@@ -107,8 +144,8 @@ export function tokenize(source: string): Token[] {
           range: {
             min: Number(range[1]),
             max: Number(range[2]),
-            mode: range[3] as '/' | '*',
-            step: Number(range[4]),
+            mode: (range[3] ?? '/') as '/' | '*',
+            step: range[4] ? Number(range[4]) : 1,
             quantum: range[5] ? Number(range[5]) : undefined,
             pad: padWidth(range[1], range[2]),
           },
@@ -158,13 +195,28 @@ export function tokenize(source: string): Token[] {
         ',': 'comma',
         '!': 'bang',
         '/': 'slash',
+        ':': 'colon',
       };
       const kind = single[text[0]];
       if (!kind) throw new DfnError(`unexpected '${text[0]}'`, line, column);
+      if (kind === 'lbracket') openBrackets.push({ line, column });
+      if (kind === 'rbracket') openBrackets.pop();
       push(kind, text[0]);
     }
 
-    tokens.push({ kind: 'newline', value: '\n', line, column });
+    // Inside a block, a newline is not a statement boundary.
+    if (openBrackets.length === 0) {
+      tokens.push({ kind: 'newline', value: '\n', line, column });
+    }
+  }
+
+  const unclosed = openBrackets[0];
+  if (unclosed) {
+    throw new DfnError(
+      `unclosed '[' opened at ${unclosed.line}:${unclosed.column}`,
+      unclosed.line,
+      unclosed.column,
+    );
   }
 
   tokens.push({ kind: 'eof', value: '', line: lines.length + 1, column: 1 });