prettier-plugin-wolfram 0.7.0

package/src/translator/nodes/ternary.js

@@ -0,0 +1,82 @@
+// src/translator/nodes/ternary.js
+import { doc } from "prettier";
+const { builders } = doc;
+import { isTrivia } from "./leaf.js";
+import {
+	hasImmediateComment,
+	printOriginalSource,
+} from "../sourcePreservation.js";
+import { normalizeWolframOptions } from "../../options.js";
+const { group, indent, line, softline } = builders;
+
+function preservedTildeFunctions(options) {
+	options = normalizeWolframOptions(options);
+	return new Set(
+		String(options.wolframPreserveTildeInfixFunctions ?? "")
+			.split(",")
+			.map((s) => s.trim())
+			.filter(Boolean),
+	);
+}
+
+function isFakeTokenLeaf(node) {
+	return node?.type === "LeafNode" && node.kind.startsWith("Token`Fake`");
+}
+
+function isSpanToken(node) {
+	return node?.type === "LeafNode" && node.kind === "Token`SemiSemi";
+}
+
+function tildeGap(token, options) {
+	options = normalizeWolframOptions(options);
+	if (options.wolframSpaceAroundOperators ?? true) {
+		return [` ${token}`, line];
+	}
+
+	return [token, softline];
+}
+
+export function printTernary(node, options, print) {
+	if (hasImmediateComment(node)) {
+		return printOriginalSource(node, options);
+	}
+
+	const semantic = node.children.filter((c) => !isTrivia(c));
+
+	if (node.op === "Span") {
+		return group(
+			semantic.map((child) => {
+				if (isSpanToken(child)) return ";;";
+				if (isFakeTokenLeaf(child)) return "";
+				return print(child);
+			}),
+		);
+	}
+
+	if (node.op === "TernaryTilde" && semantic.length === 5) {
+		const [lhs, firstTilde, fn, secondTilde, rhs] = semantic;
+		if (
+			fn.type === "LeafNode" &&
+			fn.kind === "Symbol" &&
+			preservedTildeFunctions(options).has(fn.value)
+		) {
+			return group([
+				print(lhs),
+				...tildeGap(firstTilde.value, options),
+				print(fn),
+				...tildeGap(secondTilde.value, options),
+				print(rhs),
+			]);
+		}
+
+		return group([
+			print(fn),
+			"[",
+			indent([softline, print(lhs), ",", line, print(rhs)]),
+			softline,
+			"]",
+		]);
+	}
+
+	return printOriginalSource(node, options);
+}

package/src/translator/ruleAlignment.js

@@ -0,0 +1,133 @@
+import { doc } from "prettier";
+import { renderFlatDoc } from "./docComments.js";
+import { isComment, isTrivia } from "./nodes/leaf.js";
+import { wantsSpacesAroundOperator } from "../utils/operatorSpacing.js";
+import { normalizeWolframOptions } from "../options.js";
+
+const { ifBreak } = doc.builders;
+
+const RULE_OPS = new Set(["Rule", "RuleDelayed"]);
+const RULE_DISPLAY = {
+	Rule: "->",
+	RuleDelayed: ":>",
+};
+
+function isSemanticTokenLeaf(node) {
+	return (
+		node?.type === "LeafNode" &&
+		[
+			"Token`Hash",
+			"Token`HashHash",
+			"Token`Under",
+			"Token`UnderUnder",
+			"Token`UnderUnderUnder",
+		].includes(node.kind)
+	);
+}
+
+function isFakeTokenLeaf(node) {
+	return node?.type === "LeafNode" && node.kind.startsWith("Token`Fake`");
+}
+
+function isOperatorTokenLeaf(node) {
+	return (
+		node?.type === "LeafNode" &&
+		node.kind.startsWith("Token`") &&
+		!isSemanticTokenLeaf(node) &&
+		!isFakeTokenLeaf(node)
+	);
+}
+
+function ruleParts(node) {
+	if (node?.type !== "BinaryNode" || !RULE_OPS.has(node.op)) return null;
+	if ((node.children ?? []).some((child) => isComment(child))) return null;
+
+	const semantic = node.children.filter(
+		(child) =>
+			!isTrivia(child) &&
+			!(
+				child.type === "LeafNode" &&
+				child.kind.startsWith("Token`") &&
+				!isSemanticTokenLeaf(child)
+			),
+	);
+	const [lhs, rhs] = semantic;
+	if (!lhs || !rhs) return null;
+
+	const token = node.children.find(
+		(child) => !isTrivia(child) && isOperatorTokenLeaf(child),
+	);
+	return {
+		lhs,
+		rhs,
+		token,
+		op: token?.value ?? RULE_DISPLAY[node.op],
+	};
+}
+
+function childDoc(path, print, entry, child) {
+	const childIndex = entry.node.children.indexOf(child);
+	if (childIndex === -1 || !entry.path) return null;
+	return path.call(print, ...entry.path, "children", childIndex);
+}
+
+function alignmentCandidate(path, options, print, entry) {
+	const parts = ruleParts(entry.node);
+	if (!parts) return null;
+
+	const lhsDoc = childDoc(path, print, entry, parts.lhs);
+	const rhsDoc = childDoc(path, print, entry, parts.rhs);
+	if (!lhsDoc || !rhsDoc) return null;
+
+	const lhsText = renderFlatDoc(lhsDoc, options);
+	if (lhsText.includes("\n")) return null;
+
+	return {
+		entry,
+		lhsText,
+		lhsWidth: lhsText.length,
+		rhsDoc,
+		op: parts.op,
+		token: parts.token,
+	};
+}
+
+export function withAlignedRuleValues(entries, path, options, print) {
+	options = normalizeWolframOptions(options);
+	if (!options.wolframAlignRuleValues) return entries;
+
+	const candidates = entries
+		.map((entry) => alignmentCandidate(path, options, print, entry))
+		.filter(Boolean);
+
+	if (candidates.length < 2) return entries;
+
+	const maxLhsWidth = Math.max(
+		...candidates.map((candidate) => candidate.lhsWidth),
+	);
+	for (const candidate of candidates) {
+		const hasOperatorSpace = wantsSpacesAroundOperator(
+			candidate.entry.node,
+			options,
+			candidate.token,
+		);
+		const beforeOperator =
+			maxLhsWidth - candidate.lhsWidth + (hasOperatorSpace ? 1 : 0);
+		const afterOperator = hasOperatorSpace ? " " : "";
+		candidate.entry.alignedRuleDoc = [
+			candidate.lhsText,
+			" ".repeat(beforeOperator),
+			candidate.op,
+			afterOperator,
+			candidate.rhsDoc,
+		];
+	}
+
+	return entries;
+}
+
+export function alignedRuleDoc(entry, groupId) {
+	return entry.alignedRuleDoc
+		? ifBreak(entry.alignedRuleDoc, entry.doc, { groupId })
+		: entry.doc;
+}

package/src/translator/sourceLines.js

@@ -0,0 +1,49 @@
+function lineNumberAtOffset(text, offset) {
+	if (typeof text !== "string" || typeof offset !== "number" || offset < 0) {
+		return null;
+	}
+
+	const limit = Math.min(offset, text.length);
+	let line = 1;
+	let searchFrom = 0;
+
+	while (searchFrom < limit) {
+		const newlineOffset = text.indexOf("\n", searchFrom);
+		if (newlineOffset === -1 || newlineOffset >= limit) break;
+		line++;
+		searchFrom = newlineOffset + 1;
+	}
+
+	return line;
+}
+
+export function nodeStartLine(node, options) {
+	const sourceStartLine = node?.source?.[0]?.[0];
+	if (Number.isFinite(sourceStartLine)) return sourceStartLine;
+	return lineNumberAtOffset(options?.originalText, node?.locStart);
+}
+
+export function nodeEndLine(node, options) {
+	const sourceEndLine = node?.source?.[1]?.[0];
+	if (Number.isFinite(sourceEndLine)) return sourceEndLine;
+
+	if (typeof node?.locEnd === "number") {
+		const lastIncludedOffset =
+			typeof node?.locStart === "number" && node.locEnd > node.locStart
+				? node.locEnd - 1
+				: node.locEnd;
+		return lineNumberAtOffset(options?.originalText, lastIncludedOffset);
+	}
+
+	return nodeStartLine(node, options);
+}
+
+export function sourceLineGap(leftNode, rightNode, options) {
+	const leftEndLine = nodeEndLine(leftNode, options);
+	const rightStartLine = nodeStartLine(rightNode, options);
+	if (!Number.isFinite(leftEndLine) || !Number.isFinite(rightStartLine)) {
+		return null;
+	}
+
+	return rightStartLine - leftEndLine;
+}

package/src/translator/sourcePreservation.js

@@ -0,0 +1,22 @@
+import { isComment } from "./nodes/leaf.js";
+
+export function printOriginalSource(node, options) {
+	if (
+		typeof options?.originalText === "string" &&
+		typeof node?.locStart === "number" &&
+		typeof node?.locEnd === "number" &&
+		node.locEnd >= node.locStart
+	) {
+		const source = options.originalText.slice(node.locStart, node.locEnd);
+		if (source.length > 0) return source;
+	}
+
+	return node?.wl ?? "";
+}
+
+export function hasImmediateComment(node) {
+	if (!node || typeof node !== "object") return false;
+	if (isComment(node)) return true;
+	if (isComment(node.head)) return true;
+	return (node.children ?? []).some((child) => isComment(child));
+}