@nmnmcc/ability 2.0.7 → 2.1.2

package/src/internal/nodes.ts

@@ -23,6 +23,7 @@ import type * as Effect from "effect/Effect"
 import { hasProperty } from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Limits from "./limits.ts"
+import * as Trampoline from "./trampoline.ts"
 
 /** A value that a condition can compare. */
 export type Scalar = string | number | boolean | null
@@ -83,14 +84,17 @@ const checkPath = (path: unknown): string => {
 	if (typeof path !== "string") {
 		throw new Error("A field path must be a string")
 	}
-	const parts = path.split(".", Limits.fieldPathParts + 1).length
-	if (parts > Limits.fieldPathParts) {
+	// A node does not know its domain, so it checks the ceiling. The binding
+	// to a domain checks the limit of the domain.
+	const most = Limits.ceilings.fieldPathParts
+	const parts = path.split(".", most + 1).length
+	if (parts > most) {
 		throw Limits.exceeded(
 			"A field path",
 			"fieldPathParts",
 			"parts",
 			parts,
-			Limits.fieldPathParts,
+			most,
 		)
 	}
 	return path
@@ -140,13 +144,15 @@ const valuesFacts = (values: ReadonlyArray<Operand>): Facts =>
 	checkWeight({ ...leaf, weight: 1 + values.length })
 
 const checkWeight = (facts: Facts): Facts => {
-	if (facts.weight > Limits.conditionNodes) {
+	// A node does not know its domain, so it checks the ceiling. The binding
+	// to a domain, and a decoder, check their limits.
+	if (facts.weight > Limits.ceilings.conditionNodes) {
 		throw Limits.exceeded(
 			"A condition",
 			"conditionNodes",
 			"nodes and values",
 			facts.weight,
-			Limits.conditionNodes,
+			Limits.ceilings.conditionNodes,
 		)
 	}
 	return facts
@@ -159,15 +165,6 @@ const factsOf = (children: ReadonlyArray<Node>): Facts => {
 	checkWeight({ ...leaf, weight })
 	const depth =
 		1 + Arr.reduce(children, 0, (top, child) => Math.max(top, child.depth))
-	if (depth > Limits.conditionDepth) {
-		throw Limits.exceeded(
-			"A condition",
-			"conditionDepth",
-			"levels",
-			depth,
-			Limits.conditionDepth,
-		)
-	}
 	return {
 		size,
 		weight,
@@ -382,40 +379,61 @@ const operandJson = (operand: Operand): unknown =>
 			}
 		: { _tag: "Principal", path: operand.path }
 
-/** Gives the JSON form of a condition with no predicate. */
-export const toJson = (node: Node): unknown => {
-	switch (node._tag) {
-		case "True":
-		case "False":
-			return { _tag: node._tag }
-		case "Compare":
-			return {
-				_tag: "Compare",
-				op: node.op,
-				field: node.field,
-				value: operandJson(node.value),
-			}
-		case "In":
-			return {
-				_tag: "In",
-				field: node.field,
-				values: Arr.map(node.values, operandJson),
+/**
+ * Gives the JSON form of a condition with no predicate. The walk takes the
+ * steps of a trampoline, so a deep condition does not fill the stack.
+ */
+export const toJson = (root: Node): unknown =>
+	Trampoline.run(root.depth, (R) => {
+		const go = (node: Node): Trampoline.Step<unknown> => {
+			switch (node._tag) {
+				case "True":
+				case "False":
+					return R.succeed({ _tag: node._tag })
+				case "Compare":
+					return R.succeed({
+						_tag: "Compare",
+						op: node.op,
+						field: node.field,
+						value: operandJson(node.value),
+					})
+				case "In":
+					return R.succeed({
+						_tag: "In",
+						field: node.field,
+						values: Arr.map(node.values, operandJson),
+					})
+				case "Exists":
+					return R.succeed({ _tag: "Exists", field: node.field })
+				case "Under":
+					return R.succeed({
+						_tag: "Under",
+						prefix: Arr.map(node.prefix, operandJson),
+					})
+				case "And":
+				case "Or": {
+					const tag = node._tag
+					return R.map(
+						R.forEach(node.conditions, (child) => R.suspend(() => go(child))),
+						(conditions) => ({ _tag: tag, conditions }),
+					)
+				}
+				case "Not":
+					return R.map(
+						R.suspend(() => go(node.condition)),
+						(condition) => ({
+							_tag: "Not",
+							condition,
+						}),
+					)
+				case "Predicate":
+					throw new Error(
+						`The predicate "${node.name}" can not become JSON. A condition with a predicate has no JSON form.`,
+					)
 			}
-		case "Exists":
-			return { _tag: "Exists", field: node.field }
-		case "Under":
-			return { _tag: "Under", prefix: Arr.map(node.prefix, operandJson) }
-		case "And":
-		case "Or":
-			return { _tag: node._tag, conditions: Arr.map(node.conditions, toJson) }
-		case "Not":
-			return { _tag: "Not", condition: toJson(node.condition) }
-		case "Predicate":
-			throw new Error(
-				`The predicate "${node.name}" can not become JSON. A condition with a predicate has no JSON form.`,
-			)
-	}
-}
+		}
+		return go(root)
+	})
 
 /** Tests if a value is a node. Only a constructor of a node makes one. */
 export const isNode = (u: unknown): u is Node => u instanceof Base

package/src/internal/patterns.ts

@@ -14,6 +14,7 @@
  * number of names times the number of parts.
  */
 import * as Arr from "effect/Array"
+import * as Option from "effect/Option"
 import * as Result from "effect/Result"
 import * as Catalog from "./catalog.ts"
 import * as Limits from "./limits.ts"
@@ -39,13 +40,17 @@ const partOf = (text: string): Part =>
 
 /**
  * Reads a pattern. It fails with the problem when the pattern has `**`
- * inside a part, or has more parts than `patternParts`.
+ * inside a part, or has more parts than `parts`, the `patternParts` of a
+ * domain.
  */
-export const parse = (text: string): Result.Result<Pattern, string> => {
-	const texts = text.split(".", Limits.patternParts + 1)
-	if (texts.length > Limits.patternParts) {
+export const parse = (
+	text: string,
+	parts: number = Limits.patternParts,
+): Result.Result<Pattern, string> => {
+	const texts = text.split(".", parts + 1)
+	if (texts.length > parts) {
 		return Result.fail(
-			`The field pattern "${text}" has more than ${String(Limits.patternParts)} parts. The most is ${String(Limits.patternParts)}.`,
+			`The field pattern "${text}" has more than ${String(parts)} parts. The most is ${String(parts)}.`,
 		)
 	}
 	if (Arr.some(texts, (part) => part !== "**" && part.includes("**"))) {
@@ -63,11 +68,15 @@ export const parse = (text: string): Result.Result<Pattern, string> => {
 }
 
 /**
- * Reads a pattern of a bound rule. The binding of the rule took the pattern,
- * so a problem here is a defect.
+ * Reads a pattern of a bound rule. The binding of the rule took the pattern
+ * with the limits of its domain, so this reads it up to the ceiling, and a
+ * problem here is a defect.
  */
 export const parseBound = (text: string): Pattern =>
-	Result.getOrThrowWith(parse(text), (problem) => new Error(problem))
+	Result.getOrThrowWith(
+		parse(text, Limits.ceilings.patternParts),
+		(problem) => new Error(problem),
+	)
 
 /** Tests if a name matches the pieces of a part with stars. */
 const globMatches = (pieces: ReadonlyArray<string>, name: string): boolean => {
@@ -189,27 +198,72 @@ export const matchesBelow = (
 		(state) => state < pattern.length,
 	)
 
-/** Tests if a pattern matches some field of a catalog. */
+/**
+ * Tests if a pattern matches some field of a catalog, with at most `parts`
+ * parts. A recursive Schema has no end of fields, so the search goes over the
+ * pairs of a place of the catalog and one place of the match. There are at
+ * most the places of the catalog times the parts of the pattern of them, so
+ * the work is the steps of the catalog times the parts of the pattern, as the
+ * binding counts it. Each pair comes one time, a level after a level, so the
+ * search finds the shortest field first, and it keeps a queue, so a deep
+ * Schema does not fill the stack. The set of the pairs is native, and the set
+ * and the queue belong to this call.
+ */
 export const fitsCatalog = (
 	pattern: Pattern,
 	catalog: Catalog.Catalog,
+	parts: number = Limits.fieldPathParts,
 ): boolean => {
-	const below = (branch: Catalog.Branch, states: States): boolean =>
-		states.length > 0 &&
-		(Arr.some(branch.children, ([name, child]) => visit(child, name, states)) ||
-			(branch.key !== undefined &&
-				branch.keyBranch !== undefined &&
-				visit(branch.keyBranch, branch.key, states)))
-	const visit = (
-		branch: Catalog.Branch,
-		segment: Catalog.Segment,
-		before: States,
-	): boolean => {
-		const states = step(pattern, before, segment)
-		return (
-			(branch.field !== undefined && isDone(pattern, states)) ||
-			below(branch, states)
+	interface Visit {
+		readonly branch: Catalog.Branch
+		readonly state: number
+		readonly depth: number
+	}
+	const seen = new Set<string>()
+	const visits = (
+		id: number,
+		states: States,
+		depth: number,
+	): ReadonlyArray<Visit> =>
+		Arr.flatMap(states, (state) => {
+			const key = `${String(id)}|${String(state)}`
+			if (seen.has(key)) {
+				return []
+			}
+			seen.add(key)
+			return [{ branch: catalog.branches[id]!, state, depth }]
+		})
+	const next = (visit: Visit): ReadonlyArray<Visit> => {
+		if (visit.depth === parts) {
+			return []
+		}
+		const branch = visit.branch
+		const steps: ReadonlyArray<readonly [Catalog.Segment, number]> =
+			branch.key === undefined || branch.keyBranch === undefined
+				? branch.children
+				: [...branch.children, [branch.key, branch.keyBranch] as const]
+		return Arr.flatMap(steps, ([segment, id]) =>
+			visits(id, step(pattern, [visit.state], segment), visit.depth + 1),
 		)
 	}
-	return below(catalog.root, start(pattern))
+	const queue: Array<Visit> = [...visits(catalog.root.id, start(pattern), 0)]
+	// The walk stops at the first field that the pattern matches. The visits
+	// go into the queue one at a time: a spread into a call would pass one
+	// argument for each, past the most arguments of a call.
+	return Arr.some(
+		Arr.unfold(0, (index) => {
+			const visit = queue[index]
+			if (visit === undefined) {
+				return Option.none()
+			}
+			if (visit.depth > 0 && visit.state === pattern.length) {
+				return Option.some([true, queue.length] as const)
+			}
+			Arr.forEach(next(visit), (found) => {
+				queue.push(found)
+			})
+			return Option.some([false, index + 1] as const)
+		}),
+		(match) => match,
+	)
 }