@tikoci/centrs 0.1.9-next.0 → 0.1.9-next.23

package/src/explain/args.ts

@@ -87,7 +87,7 @@ import {
 } from "./segment.ts";
 
 /** A RouterOS argument name: bare word, optionally dotted (`.id`, `.proplist`). */
-const ARGUMENT_NAME = /^\.?[A-Za-z][A-Za-z0-9._-]*$/;
+export const ARGUMENT_NAME = /^\.?[A-Za-z][A-Za-z0-9._-]*$/;
 
 /** What one argument token is. */
 export type ArgumentKind = "attribute" | "positional" | "query";
@@ -327,6 +327,12 @@ interface WalkOptions {
 	 * see {@link braceSlotTakesArray}.
 	 */
 	directiveVerb?: string;
+	/**
+	 * Where a command's top-level `where` positional ends, set by the walk itself
+	 * once it reads one. From there on a brace is an expression value
+	 * (see {@link comparesNamedValue}).
+	 */
+	whereAt?: number;
 }
 
 /** How deep member scanning descends before it stops and keeps only the shape. */
@@ -363,7 +369,11 @@ function braceOpensArray(
 	options: WalkOptions,
 ): boolean {
 	const verb = options.directiveVerb;
-	if (verb === undefined) return false;
+	if (verb === undefined)
+		return (
+			options.whereAt !== undefined &&
+			!comparesNamedValue(text, at, options.whereAt)
+		);
 	const owner = braceValueOwner(text, tokenStart, at);
 	if (owner === undefined) return false;
 	return braceSlotTakesArray(
@@ -390,6 +400,7 @@ function* walkArguments(
 	let i = Math.max(0, from);
 	// How many positionals have been read, which is the NEXT positional's index.
 	let positionals = 0;
+	let walk = options;
 	while (i < text.length) {
 		// The MASKED view decides whitespace, because `maskComments` blanks a
 		// continuation comment that `text` still spells with a `#`. Reading `text`
@@ -412,7 +423,7 @@ function* walkArguments(
 			i += continuation;
 			continue;
 		}
-		const token = scanToken(text, structural, i, positionals, options);
+		const token = scanToken(text, structural, i, positionals, walk);
 		if (typeof token === "string") {
 			yield token;
 			return;
@@ -430,7 +441,7 @@ function* walkArguments(
 		// the refusal exists to prevent. Shape only, never a value.
 		const read =
 			token.why === undefined
-				? readToken(text, structural, i, token.end, options)
+				? readToken(text, structural, i, token.end, walk)
 				: undecidedToken(text, i, token.end, token.why);
 		if (typeof read === "string") {
 			if (options.tolerant !== true) {
@@ -446,6 +457,13 @@ function* walkArguments(
 			continue;
 		}
 		if (read.kind === "positional") positionals++;
+		if (
+			read.kind === "positional" &&
+			read.text === "where" &&
+			walk.directiveVerb === undefined &&
+			walk.whereAt === undefined
+		)
+			walk = { ...walk, whereAt: token.end };
 		yield read;
 		i = token.end;
 	}
@@ -1661,13 +1679,51 @@ export function lexValueAnchors(
 	return { complete: true, anchors };
 }
 
+/**
+ * Whether the brace at `at` is the right side of a `where` comparison that
+ * RouterOS reads with the named property's own value parser (#502).
+ *
+ * A `where` clause is expression context, so a brace there is an array value —
+ * except straight after `<name>=`, `<name>!=` or `<name>==`, spaced or not.
+ * On CHR 7.24.5 and 7.23.8, `:parse` rejects `/ip/route/print where
+ * comment={1;2}` with `expected comment value`, and `where disabled={…}` with
+ * `expected yes or no`. It accepts the brace after `in`, `~`, `<`, `>`, `<=`
+ * and `>=`, on the left of `=`, and after `!interface=`, `$x=` and `"a"=`.
+ *
+ * Only a property name the menu KNOWS is read this way: `where foo-bar={…}` is
+ * accepted. Offline has no per-menu property list (decision 3), so every bare
+ * name counts, and an unknown one is a pinned over-strict reading.
+ *
+ * The name may open a group, `where (interface={"x"})` and `or(comment={…})`,
+ * which `group-faults.ts` asks about (#509).
+ */
+export function comparesNamedValue(
+	text: string,
+	at: number,
+	floor: number,
+): boolean {
+	let j = at - 1;
+	while (j > floor && /\s/.test(text[j] as string)) j--;
+	if (text[j] !== "=") return false;
+	while (j > floor && text[j] === "=") j--;
+	if (text[j] === "<" || text[j] === ">") return false;
+	if (text[j] === "!") j--;
+	while (j > floor && /\s/.test(text[j] as string)) j--;
+	const nameEnd = j + 1;
+	while (j > floor && /[A-Za-z0-9._-]/.test(text[j] as string)) j--;
+	const name = text.slice(j + 1, nameEnd);
+	return /^[A-Za-z.]/.test(name) && /[\s(]/.test(text[j] as string);
+}
+
 /**
  * Locate top-level `{...}` values that RouterOS rejects in command arguments.
  *
  * Parentheses and substitutions restore expression context, where a brace
- * literal is legal. Stored-script attributes are also excluded: their brace is
- * a script body, not an array. The caller applies this only to non-root
- * commands; root scripting directives use the `(verb, slot)` table instead.
+ * literal is legal, and so does a `where` clause, apart from the comparisons
+ * {@link comparesNamedValue} names. Stored-script attributes are also
+ * excluded: their brace is a script body, not an array. The caller applies
+ * this only to non-root commands; root scripting directives use the
+ * `(verb, slot)` table instead.
  */
 export function invalidCommandBraceOffsets(
 	text: string,
@@ -1681,6 +1737,7 @@ export function invalidCommandBraceOffsets(
 	let i = Math.max(0, from);
 	let tokenStart: number | null = null;
 	let positionals = 0;
+	let whereAt: number | null = null;
 	while (i < structural.length) {
 		const c = structural[i] as string;
 		if (
@@ -1689,6 +1746,7 @@ export function invalidCommandBraceOffsets(
 		) {
 			if (tokenStart !== null) {
 				const token = structural.slice(tokenStart, i);
+				if (whereAt === null && token === "where") whereAt = i;
 				if (
 					!token.startsWith("?") &&
 					unquotedEquals(token, 0, token.length) === null
@@ -1737,7 +1795,10 @@ export function invalidCommandBraceOffsets(
 				: braceStartsStatements(range.masked, range.start + i, range.start)) ||
 			(directiveVerb !== undefined &&
 				slot !== undefined &&
-				braceSlotAcceptsBrace(directiveVerb, slot))
+				braceSlotAcceptsBrace(directiveVerb, slot)) ||
+			(directiveVerb === undefined &&
+				whereAt !== null &&
+				!comparesNamedValue(structural, i, whereAt))
 		) {
 			i = end ?? structural.length;
 			continue;

package/src/explain/blocks.ts

@@ -13,10 +13,9 @@
  * name (and, for the one head-dependent case, the leading directive) off the
  * statement itself.
  *
- * This module ships only the (single-pass, non-recursive) classification
- * primitives the path resolver needs. The recursive block *tree* / topology
- * surface stays in the lab until it can be promoted with a bounded, index-based
- * traversal of its own.
+ * This module ships the single-pass, non-recursive classification primitives
+ * the path resolver needs. `explain.ts` publishes source ownership from that
+ * resolver's existing bounded traversal; `scopeBlocks` remains a shallow scan.
  *
  * Every string skip here goes through `segment.ts`'s `scanQuotedString` rather
  * than a local quote-to-quote loop, so this module and the segmenter cannot

package/src/explain/brace-slots.ts

@@ -134,6 +134,11 @@ export function braceSlotTakesArray(verb: string, slot: string): boolean {
 	return BRACE_ARRAY_SLOTS.get(verb)?.has(slot) === true;
 }
 
+/** Whether a `{…}` in this root-directive slot is code or script text. */
+export function braceSlotTakesProgram(verb: string, slot: string): boolean {
+	return BRACE_PROGRAM_SLOTS.get(verb)?.has(slot) === true;
+}
+
 /** Whether the device sweep proved this root-directive slot accepts `{...}`. */
 export function braceSlotAcceptsBrace(verb: string, slot: string): boolean {
 	return (

package/src/explain/catalog.ts

@@ -1317,6 +1317,11 @@ export function lookupPath(
 	return PATH_CATALOG.get(`/${segments.join("/").toLowerCase()}`);
 }
 
+/** Segments in the deepest catalog path; no lookup past it can match. */
+const MAX_PATH_DEPTH = Math.max(
+	...Array.from(PATH_CATALOG.keys(), (path) => path.split("/").length - 1),
+);
+
 /**
  * Where a published COMMAND ends inside a path run: the index of the run
  * segment that is the VERB, or `null` when no prefix of `segments` is one.
@@ -1340,12 +1345,14 @@ export function lookupPath(
  * question; what the segment IS is not.
  */
 export function commandVerbIndex(segments: readonly string[]): number | null {
-	for (let depth = 1; depth <= segments.length; depth++)
-		if (
-			PATH_CATALOG.get(`/${segments.slice(0, depth).join("/").toLowerCase()}`)
-				?.kind === "command"
-		)
-			return depth - 1;
+	// Bounded by the deepest row and built incrementally: a run of thousands of
+	// bare words would otherwise re-join every prefix (#496).
+	const limit = Math.min(segments.length, MAX_PATH_DEPTH);
+	let path = "";
+	for (let depth = 0; depth < limit; depth++) {
+		path += `/${(segments[depth] as string).toLowerCase()}`;
+		if (PATH_CATALOG.get(path)?.kind === "command") return depth;
+	}
 	return null;
 }
 

package/src/explain/defects.ts

@@ -99,6 +99,7 @@ export type DefectCode =
 	| "over-depth"
 	| "bad-escape"
 	| "bad-string-escape"
+	| "bad-string-variable"
 	| "bad-sigil"
 	| "invalid-hash"
 	| "invalid-apostrophe"