@effected/yaml 0.6.1 → 0.8.0

package/internal/rules/truthy.js

@@ -0,0 +1,84 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { positionAt, walkScalars } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/truthy.ts
+/**
+* Options for `truthy`: the `allowed` boolean spellings (default
+* `["true", "false"]`) and whether mapping keys are checked (`checkKeys`,
+* default `true` — the workflow `on:` key is the point).
+*/
+const truthyOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	allowed: Schema.optionalKey(Schema.Array(Schema.String)),
+	checkKeys: Schema.optionalKey(Schema.Boolean)
+});
+/** The YAML 1.1 boolean family, per spelling case the 1.1 grammar admits. */
+const TRUTHY = /* @__PURE__ */ new Set([
+	"yes",
+	"Yes",
+	"YES",
+	"no",
+	"No",
+	"NO",
+	"on",
+	"On",
+	"ON",
+	"off",
+	"Off",
+	"OFF",
+	"true",
+	"True",
+	"TRUE",
+	"false",
+	"False",
+	"FALSE"
+]);
+const TRUE_SET = /* @__PURE__ */ new Set([
+	"yes",
+	"on",
+	"true"
+]);
+/** YAML 1.1 truthy spellings outside the allowed list. */
+const truthy = {
+	id: "truthy",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const allowed = new Set(opts.allowed ?? ["true", "false"]);
+		const checkKeys = opts.checkKeys ?? true;
+		const out = [];
+		walkScalars(ctx.document.contents, "root", (scalar, role) => {
+			if (role === "key" && !checkKeys) return;
+			if (scalar.style !== "plain" || scalar.tag !== void 0) return;
+			const raw = ctx.text.slice(scalar.offset, scalar.offset + scalar.length);
+			if (!TRUTHY.has(raw) || allowed.has(raw)) return;
+			const pos = positionAt(ctx.lines, scalar.offset);
+			const isBool = typeof scalar.value === "boolean";
+			const respell = TRUE_SET.has(raw.toLowerCase()) ? "true" : "false";
+			const fix = isBool ? allowed.has(respell) ? YamlEdit.make({
+				offset: scalar.offset,
+				length: scalar.length,
+				content: respell
+			}) : void 0 : YamlEdit.make({
+				offset: scalar.offset,
+				length: scalar.length,
+				content: `"${raw}"`
+			});
+			out.push(new YamlLintDiagnostic({
+				rule: "truthy",
+				severity: "error",
+				message: `Truthy value "${raw}" is not in the allowed spellings`,
+				offset: scalar.offset,
+				length: scalar.length,
+				line: pos.line,
+				character: pos.character,
+				...fix !== void 0 ? { fix } : {}
+			}));
+		});
+		return out;
+	}
+};
+
+//#endregion
+export { truthy, truthyOptions };

package/internal/rules/util.js

@@ -0,0 +1,92 @@
+import { YamlMap, YamlScalar, YamlSeq } from "../../YamlNode.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/util.ts
+/**
+* A non-negative integer — the shape every numeric rule option takes.
+* Rejects NaN, negatives and fractions with a message naming the constraint;
+* the config layer's wrapper names the rule and the field.
+*/
+const nonNegativeIntegerOption = Schema.Number.check(Schema.makeFilter((n) => Number.isInteger(n) && n >= 0 ? void 0 : "Expected a non-negative integer"));
+/**
+* A positive integer — for the `maxSpacesAfter` options, where `0` would make
+* the fix delete the separation space after an indicator and fuse it with its
+* content (`- item` → `-item`, `a: val` → `a:val` — different tokens, not a
+* spacing change).
+*/
+const positiveIntegerOption = Schema.Number.check(Schema.makeFilter((n) => Number.isInteger(n) && n >= 1 ? void 0 : "Expected an integer greater than or equal to 1"));
+/** Depth-first walk over every scalar node with its structural role. */
+function walkScalars(node, role, visit) {
+	if (node === null) return;
+	if (node instanceof YamlScalar) {
+		visit(node, role);
+		return;
+	}
+	if (node instanceof YamlMap) {
+		for (const pair of node.items) {
+			walkScalars(pair.key, "key", visit);
+			walkScalars(pair.value, "value", visit);
+		}
+		return;
+	}
+	if (node instanceof YamlSeq) for (const item of node.items) walkScalars(item, "item", visit);
+}
+/**
+* True when the first content of a line is the CONTINUATION of a scalar
+* token that began on an earlier line — block-scalar bodies and multi-line
+* plain/quoted scalars. The indentation rule skips such lines: their layout
+* is the value's, not block structure's.
+*/
+function isScalarContinuationLine(tokens, lineOffset, probeOffset) {
+	const token = coveringToken(tokens, probeOffset);
+	return token !== void 0 && token.kind === "scalar" && token.offset < lineOffset;
+}
+/** The token whose span covers `offset`, when one does. */
+function coveringToken(tokens, offset) {
+	let lo = 0;
+	let hi = tokens.length - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const token = tokens[mid];
+		if (offset < token.offset) hi = mid - 1;
+		else if (offset >= token.offset + token.length) lo = mid + 1;
+		else return token;
+	}
+}
+/**
+* True when `offset` falls inside a scalar token's span. Layout rules use
+* this to stay off scalar CONTENT — trailing whitespace or blank lines
+* inside a block scalar are part of the parsed value, and a lint layer that
+* edits content under the banner of layout is corrupting, not fixing.
+*/
+function insideScalarSpan(tokens, offset) {
+	return coveringToken(tokens, offset)?.kind === "scalar";
+}
+/**
+* The line containing `offset` and the character index within it — a binary
+* search over the ordered `LintLine` array (lines are ordered by `offset`,
+* the same invariant {@link coveringToken} rests on for tokens).
+*/
+function positionAt(lines, offset) {
+	let lo = 0;
+	let hi = lines.length - 1;
+	let found;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const line = lines[mid];
+		if (line.offset <= offset) {
+			found = line;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return found === void 0 ? {
+		line: 0,
+		character: 0
+	} : {
+		line: found.number,
+		character: offset - found.offset
+	};
+}
+
+//#endregion
+export { coveringToken, insideScalarSpan, isScalarContinuationLine, nonNegativeIntegerOption, positionAt, positiveIntegerOption, walkScalars };