@effected/yaml 0.7.0 → 0.9.0

package/internal/rules/eof-newline.js

@@ -0,0 +1,33 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/eof-newline.ts
+/** Options for `eof-newline` (severity only — nothing to tune). */
+const eofNewlineOptions = Schema.Struct({ severity: Schema.optionalKey(YamlLintSeverity) });
+/** A missing final newline, with an inserting fix. */
+const eofNewline = {
+	id: "eof-newline",
+	check: (ctx) => {
+		if (ctx.text.length === 0 || ctx.text.endsWith("\n")) return [];
+		const lastLine = ctx.lines[ctx.lines.length - 1];
+		if (lastLine === void 0) return [];
+		return [new YamlLintDiagnostic({
+			rule: "eof-newline",
+			severity: "error",
+			message: "No newline at end of file",
+			offset: ctx.text.length,
+			length: 0,
+			line: lastLine.number,
+			character: lastLine.text.length,
+			fix: YamlEdit.make({
+				offset: ctx.text.length,
+				length: 0,
+				content: "\n"
+			})
+		})];
+	}
+};
+
+//#endregion
+export { eofNewline, eofNewlineOptions };

package/internal/rules/hyphen-spacing.js

@@ -0,0 +1,52 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { positiveIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/hyphen-spacing.ts
+/**
+* Options for `hyphen-spacing`: `maxSpacesAfter` (default 1) after the `-`.
+* At least one separation space must follow the indicator — `0` would make
+* the fix emit `-item`, a plain scalar, not a sequence entry.
+*/
+const hyphenSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	maxSpacesAfter: Schema.optionalKey(positiveIntegerOption)
+});
+/** Spacing after the block-sequence `-` indicator. */
+const hyphenSpacing = {
+	id: "hyphen-spacing",
+	check: (ctx, options) => {
+		const maxAfter = Math.max(1, (options ?? {}).maxSpacesAfter ?? 1);
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "block-seq-entry") continue;
+			let j = token.offset + token.length;
+			let after = 0;
+			while (j < ctx.text.length && ctx.text[j] === " ") {
+				after++;
+				j++;
+			}
+			const next = ctx.text[j];
+			if (next === void 0 || next === "\n" || next === "\r" || next === "#") continue;
+			if (after > maxAfter) out.push(new YamlLintDiagnostic({
+				rule: "hyphen-spacing",
+				severity: "error",
+				message: `Too many spaces after "-" (${after} > ${maxAfter})`,
+				offset: token.offset + token.length,
+				length: after,
+				line: token.line,
+				character: token.character + token.length,
+				fix: YamlEdit.make({
+					offset: token.offset + token.length,
+					length: after - maxAfter,
+					content: ""
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { hyphenSpacing, hyphenSpacingOptions };

package/internal/rules/indentation.js

@@ -0,0 +1,103 @@
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { coveringToken, isScalarContinuationLine, nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/indentation.ts
+/**
+* Options for `indentation`: `spaces` per level (number or "consistent",
+* default "consistent") and `indentSequences` (boolean or "consistent",
+* default "consistent").
+*/
+const indentationOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	spaces: Schema.optionalKey(Schema.Union([nonNegativeIntegerOption, Schema.Literals(["consistent"])])),
+	indentSequences: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Literals(["consistent"])]))
+});
+/** Flow-collection depth at each line start, from the token stream. */
+const flowDepthAtLineStarts = (ctx) => {
+	const depths = [];
+	let depth = 0;
+	let tokenIdx = 0;
+	for (const line of ctx.lines) {
+		while (tokenIdx < ctx.tokens.length) {
+			const token = ctx.tokens[tokenIdx];
+			if (token === void 0 || token.offset + token.length > line.offset) break;
+			if (token.kind === "flow-map-start" || token.kind === "flow-seq-start") depth++;
+			if (token.kind === "flow-map-end" || token.kind === "flow-seq-end") depth = Math.max(0, depth - 1);
+			tokenIdx++;
+		}
+		depths.push(depth);
+	}
+	return depths;
+};
+/** Block-structure indent style. */
+const indentation = {
+	id: "indentation",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const spacesOpt = opts.spaces ?? "consistent";
+		const seqOpt = opts.indentSequences ?? "consistent";
+		const out = [];
+		const flowDepths = flowDepthAtLineStarts(ctx);
+		const content = [];
+		for (const line of ctx.lines) {
+			const indent = line.text.length - line.text.trimStart().length;
+			const firstChar = line.text[indent];
+			if (firstChar === void 0) continue;
+			if (firstChar === "#") continue;
+			if (firstChar === "%") continue;
+			if (line.text.slice(0, indent).includes("	")) continue;
+			if ((flowDepths[line.number] ?? 0) > 0) continue;
+			if (isScalarContinuationLine(ctx.tokens, line.offset, line.offset + indent)) continue;
+			if (line.text.slice(indent).startsWith("---") || line.text.slice(indent).startsWith("...")) continue;
+			content.push({
+				line,
+				indent,
+				firstChar
+			});
+		}
+		let unit = typeof spacesOpt === "number" ? spacesOpt : void 0;
+		const stack = [0];
+		for (const { line, indent } of content) {
+			const top = stack[stack.length - 1];
+			if (indent > top) {
+				const delta = indent - top;
+				if (unit === void 0) unit = delta;
+				else if (delta !== unit) out.push(new YamlLintDiagnostic({
+					rule: "indentation",
+					severity: "error",
+					message: `Indent of ${delta} spaces, expected ${unit}`,
+					offset: line.offset,
+					length: indent,
+					line: line.number,
+					character: 0
+				}));
+				stack.push(indent);
+			} else if (indent < top) while (stack.length > 1 && stack[stack.length - 1] > indent) stack.pop();
+		}
+		let seqIndented = typeof seqOpt === "boolean" ? seqOpt : void 0;
+		for (let i = 1; i < content.length; i++) {
+			const prev = content[i - 1];
+			const curr = content[i];
+			if (curr.firstChar !== "-") continue;
+			if (coveringToken(ctx.tokens, curr.line.offset + curr.indent)?.kind !== "block-seq-entry") continue;
+			if (!prev.line.text.replace(/ #.*$/, "").trimEnd().endsWith(":")) continue;
+			if (curr.indent !== prev.indent && curr.indent !== prev.indent + (unit ?? curr.indent - prev.indent)) continue;
+			const indented = curr.indent > prev.indent;
+			if (seqIndented === void 0) seqIndented = indented;
+			else if (indented !== seqIndented) out.push(new YamlLintDiagnostic({
+				rule: "indentation",
+				severity: "error",
+				message: seqIndented ? "Sequence under a mapping key should be indented" : "Sequence under a mapping key should not be indented",
+				offset: curr.line.offset,
+				length: curr.indent,
+				line: curr.line.number,
+				character: 0
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { indentation, indentationOptions };

package/internal/rules/key-duplicates.js

@@ -0,0 +1,49 @@
+import { YamlMap, YamlScalar, YamlSeq } from "../../YamlNode.js";
+import { keyIdentity } from "../composer/block.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { positionAt } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/key-duplicates.ts
+/** Options for `key-duplicates` (severity only — duplicates are duplicates). */
+const keyDuplicatesOptions = Schema.Struct({ severity: Schema.optionalKey(YamlLintSeverity) });
+const walk = (node, text, out, ctx) => {
+	if (node === null) return;
+	if (node instanceof YamlMap) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const pair of node.items) {
+			if (pair.key instanceof YamlScalar) {
+				const id = keyIdentity(pair.key, text);
+				if (seen.has(id)) {
+					const pos = positionAt(ctx.lines, pair.key.offset);
+					out.push(new YamlLintDiagnostic({
+						rule: "key-duplicates",
+						severity: "error",
+						message: `Duplicate key: ${String(pair.key.value)}`,
+						offset: pair.key.offset,
+						length: pair.key.length,
+						line: pos.line,
+						character: pos.character
+					}));
+				}
+				seen.add(id);
+			}
+			walk(pair.key, text, out, ctx);
+			walk(pair.value, text, out, ctx);
+		}
+		return;
+	}
+	if (node instanceof YamlSeq) for (const item of node.items) walk(item, text, out, ctx);
+};
+/** Duplicate mapping keys anywhere in the document. */
+const keyDuplicates = {
+	id: "key-duplicates",
+	check: (ctx) => {
+		const out = [];
+		walk(ctx.document.contents, ctx.text, out, ctx);
+		return out;
+	}
+};
+
+//#endregion
+export { keyDuplicates, keyDuplicatesOptions };

package/internal/rules/line-length.js

@@ -0,0 +1,36 @@
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/line-length.ts
+/**
+* Options for `line-length`. `max` defaults to 120 — the kit-native line
+* width (the yamllint id is recognizable; the option surface and defaults
+* are ours).
+*/
+const lineLengthOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	max: Schema.optionalKey(nonNegativeIntegerOption)
+});
+const DEFAULT_MAX = 120;
+/** Lines longer than the configured maximum. */
+const lineLength = {
+	id: "line-length",
+	check: (ctx, options) => {
+		const max = options?.max ?? DEFAULT_MAX;
+		const out = [];
+		for (const line of ctx.lines) if (line.text.length > max) out.push(new YamlLintDiagnostic({
+			rule: "line-length",
+			severity: "error",
+			message: `Line is longer than ${max} characters (${line.text.length})`,
+			offset: line.offset + max,
+			length: line.text.length - max,
+			line: line.number,
+			character: max
+		}));
+		return out;
+	}
+};
+
+//#endregion
+export { lineLength, lineLengthOptions };

package/internal/rules/parse-validity.js

@@ -0,0 +1,33 @@
+import { YamlLintDiagnostic } from "../../YamlLintRule.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/parse-validity.ts
+/**
+* parse-validity accepts no options; the config layer additionally rejects
+* any attempt to set a severity or `"off"` on this rule.
+*/
+const parseValidityOptions = Schema.Struct({});
+/** The always-on parse-validity rule. */
+const parseValidity = {
+	id: "parse-validity",
+	check: (ctx) => [...ctx.document.errors.map((d) => new YamlLintDiagnostic({
+		rule: "parse-validity",
+		severity: "error",
+		message: d.message,
+		offset: d.offset,
+		length: d.length,
+		line: d.line,
+		character: d.character
+	})), ...ctx.document.warnings.map((d) => new YamlLintDiagnostic({
+		rule: "parse-validity",
+		severity: "warning",
+		message: d.message,
+		offset: d.offset,
+		length: d.length,
+		line: d.line,
+		character: d.character
+	}))]
+};
+
+//#endregion
+export { parseValidity, parseValidityOptions };

package/internal/rules/quoted-strings.js

@@ -0,0 +1,81 @@
+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/quoted-strings.ts
+/**
+* Options for `quoted-strings`: the preferred `quoteType` (default
+* `"double"`) and whether plain string scalars are `required` to be quoted
+* at all (default `false` — only already-quoted scalars are policed).
+*/
+const quotedStringsOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	quoteType: Schema.optionalKey(Schema.Literals(["single", "double"])),
+	required: Schema.optionalKey(Schema.Boolean)
+});
+/** A value-preserving requote/wrap edit, or undefined when none is safe. */
+const safeQuoteFix = (ctx, scalar, quote) => {
+	if (scalar.tag !== void 0 || scalar.anchor !== void 0) return void 0;
+	if (typeof scalar.value !== "string") return void 0;
+	const raw = ctx.text.slice(scalar.offset, scalar.offset + scalar.length);
+	if (raw.includes("\n")) return void 0;
+	const inner = scalar.style === "plain" ? raw : raw.slice(1, -1);
+	if (inner !== scalar.value) return void 0;
+	if (inner.includes(quote)) return void 0;
+	if (quote === "\"" && inner.includes("\\")) return void 0;
+	return YamlEdit.make({
+		offset: scalar.offset,
+		length: scalar.length,
+		content: `${quote}${inner}${quote}`
+	});
+};
+/** Quote-style policy for string value scalars. */
+const quotedStrings = {
+	id: "quoted-strings",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const quoteType = opts.quoteType ?? "double";
+		const required = opts.required ?? false;
+		const quote = quoteType === "double" ? "\"" : "'";
+		const wrongStyle = quoteType === "double" ? "single-quoted" : "double-quoted";
+		const out = [];
+		walkScalars(ctx.document.contents, "root", (scalar, role) => {
+			if (role === "key") return;
+			if (typeof scalar.value !== "string") return;
+			if (scalar.style === wrongStyle) {
+				const fix = safeQuoteFix(ctx, scalar, quote);
+				const pos = positionAt(ctx.lines, scalar.offset);
+				out.push(new YamlLintDiagnostic({
+					rule: "quoted-strings",
+					severity: "error",
+					message: `String should use ${quoteType} quotes`,
+					offset: scalar.offset,
+					length: scalar.length,
+					line: pos.line,
+					character: pos.character,
+					...fix !== void 0 ? { fix } : {}
+				}));
+				return;
+			}
+			if (required && scalar.style === "plain" && scalar.length > 0) {
+				const fix = safeQuoteFix(ctx, scalar, quote);
+				const pos = positionAt(ctx.lines, scalar.offset);
+				out.push(new YamlLintDiagnostic({
+					rule: "quoted-strings",
+					severity: "error",
+					message: `String should be quoted (${quoteType})`,
+					offset: scalar.offset,
+					length: scalar.length,
+					line: pos.line,
+					character: pos.character,
+					...fix !== void 0 ? { fix } : {}
+				}));
+			}
+		});
+		return out;
+	}
+};
+
+//#endregion
+export { quotedStrings, quotedStringsOptions };

package/internal/rules/trailing-spaces.js

@@ -0,0 +1,39 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { insideScalarSpan } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/trailing-spaces.ts
+/** Options for `trailing-spaces` (severity only — nothing to tune). */
+const trailingSpacesOptions = Schema.Struct({ severity: Schema.optionalKey(YamlLintSeverity) });
+/** Trailing spaces or tabs at the end of a line, with a deleting fix. */
+const trailingSpaces = {
+	id: "trailing-spaces",
+	check: (ctx) => {
+		const out = [];
+		for (const line of ctx.lines) {
+			const match = /[ \t]+$/.exec(line.text);
+			if (match === null) continue;
+			const runOffset = line.offset + match.index;
+			if (insideScalarSpan(ctx.tokens, runOffset)) continue;
+			out.push(new YamlLintDiagnostic({
+				rule: "trailing-spaces",
+				severity: "error",
+				message: "Trailing whitespace",
+				offset: runOffset,
+				length: match[0].length,
+				line: line.number,
+				character: match.index,
+				fix: YamlEdit.make({
+					offset: runOffset,
+					length: match[0].length,
+					content: ""
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { trailingSpaces, trailingSpacesOptions };

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 };