prettier-plugin-wolfram 0.7.13 → 0.7.15

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "prettier-plugin-wolfram",
-	"version": "0.7.13",
+	"version": "0.7.15",
 	"description": "Prettier plugin for Wolfram Language using tree-sitter",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git://github.com/ToneAr/prettier-plugin-wolfram.git"
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram.git"
+	},
+	"homepage": "https://github.com/ToneAr/prettier-plugin-wolfram#readme",
+	"bugs": {
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram/issues"
 	},
 	"keywords": [
 		"prettier",
@@ -55,8 +59,5 @@
 	},
 	"workspaces": [
 		"vscode-extension"
-	],
-	"engines": {
-		"vscode": "^1.105.0"
-	}
+	]
 }

package/src/options.js

@@ -15,6 +15,9 @@ function wolframOptionDefinition(definition) {
 	return {
 		type: definition.type,
 		category: "Wolfram",
+		...(hasOwn(definition, "exception")
+			? { exception: definition.exception }
+			: {}),
 		...(hasOwn(definition, "default")
 			? { default: definition.default }
 			: {}),
@@ -22,42 +25,61 @@ function wolframOptionDefinition(definition) {
 	};
 }
 
+function isBlankLineRange(value) {
+	return (
+		isPlainObject(value) &&
+		Number.isInteger(value.min) &&
+		Number.isInteger(value.max) &&
+		value.min >= 0 &&
+		value.max >= value.min
+	);
+}
+
+function blankLineRangeOption(defaultValue, description) {
+	return {
+		type: "int",
+		...(defaultValue == null ? {} : { default: defaultValue }),
+		exception: (value) =>
+			(Number.isInteger(value) && value >= 0) || isBlankLineRange(value),
+		description,
+	};
+}
+
 export const wolframOptions = {
 	newlinesBetweenDefinitions: {
-		type: "int",
-		default: 1,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 1, max: 1 },
+			"Allowed blank lines between adjacent definitions.",
+		),
 		legacyName: "wolframNewlinesBetweenDefinitions",
-		description: "Blank lines inserted between adjacent definitions.",
 	},
 	newlinesBetweenSetDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDefinitions",
-		description:
-			"Blank lines inserted between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetAndSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetAndSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSameNameDefinitions: {
-		type: "int",
-		default: 0,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 0, max: 0 },
+			"Allowed blank lines between adjacent definitions that belong to the same symbol.",
+		),
 		legacyName: "wolframNewlinesBetweenSameNameDefinitions",
-		description:
-			"Blank lines inserted between adjacent definitions that belong to the same symbol.",
 	},
 	maxBlankLinesBetweenCode: {
 		type: "int",

package/src/translator/nodes/call.js

@@ -10,6 +10,7 @@ import {
 	withMarkedTrailingCommentDocs,
 } from "../docComments.js";
 import { normalizeWolframOptions } from "../../options.js";
+import { buildDispatchSets } from "../specialForms.js";
 const { group, indent, softline, line, hardline } = builders;
 
 const BRACKET_KINDS = new Set(["Token`OpenSquare", "Token`CloseSquare"]);
@@ -40,6 +41,24 @@ function hasCommentBoundary(leftEntry, rightEntry) {
 	return isComment(leftEntry?.node) || isComment(rightEntry?.node);
 }
 
+function callHeadName(node) {
+	return node.head?.type === "LeafNode" && node.head.kind === "Symbol"
+		? node.head.value
+		: null;
+}
+
+function shouldBreakCommentedSpecialCall(node, options, entries) {
+	if (!entries.some((entry) => isComment(entry.node))) return false;
+	const name = callHeadName(node);
+	if (!name) return false;
+	const sets = buildDispatchSets(options);
+	return (
+		sets.conditionFirst.has(name) ||
+		sets.blockStructure.has(name) ||
+		sets.caseStructure.has(name)
+	);
+}
+
 function commentBoundary(leftEntry, rightEntry, options, fallback = line) {
 	if (!leftEntry || !rightEntry) return fallback;
 	return commentBoundarySeparator(
@@ -321,5 +340,8 @@ export function printCall(path, options, print, node) {
 	);
 	const contents = [head, "[", indent([softline, ...docs]), softline, "]"];
 
-	return grouped(contents, alignmentGroupId);
+	const shouldBreak = shouldBreakCommentedSpecialCall(node, options, entries);
+	return alignmentGroupId
+		? group(contents, { id: alignmentGroupId, shouldBreak })
+		: group(contents, { shouldBreak });
 }

package/src/translator/specialForms.js

@@ -95,6 +95,10 @@ function isCommaToken(node) {
 	return node?.type === "LeafNode" && node.kind === "Token`Comma";
 }
 
+function isCommentNode(node) {
+	return node?.type === "LeafNode" && node.kind === "Token`Comment";
+}
+
 function isStringJoinOperatorToken(node) {
 	return node?.type === "LeafNode" && node.kind === "Token`LessGreater";
 }
@@ -459,7 +463,7 @@ function semanticGroupEntries(callNode, groupNode) {
 	) {
 		const commaWrapperIdx = groupNode.children.indexOf(semanticChildren[0]);
 		return semanticChildren[0].children.reduce((entries, child, idx) => {
-			if (isTrivia(child)) return entries;
+			if (isTrivia(child) || isCommentNode(child)) return entries;
 			if (child.type === "LeafNode" && child.kind === "Token`Comma")
 				return entries;
 			entries.push({
@@ -477,7 +481,7 @@ function semanticGroupEntries(callNode, groupNode) {
 	}
 
 	return (groupNode.children ?? []).reduce((entries, child, idx) => {
-		if (isTrivia(child)) return entries;
+		if (isTrivia(child) || isCommentNode(child)) return entries;
 		if (
 			child.type === "LeafNode" &&
 			(child.kind === "Token`OpenCurly" ||

package/src/utils/codeSpacing.js

@@ -35,6 +35,27 @@ export function nonNegativeIntegerOption(value, fallback) {
 	return Math.max(0, Math.floor(numeric));
 }
 
+function blankLineRangeOption(value, fallback) {
+	if (value == null) return fallback;
+	if (typeof value === "object" && !Array.isArray(value)) {
+		const min = nonNegativeIntegerOption(value.min, fallback.min);
+		const max = nonNegativeIntegerOption(value.max, fallback.max);
+		return { min, max: Math.max(min, max) };
+	}
+
+	const exact = nonNegativeIntegerOption(value, fallback.min);
+	return { min: exact, max: exact };
+}
+
+function exactBlankLineRange(value) {
+	return { min: value, max: value };
+}
+
+function blankLinesFromRange(observedBlankLines, range) {
+	const observed = nonNegativeIntegerOption(observedBlankLines, 0);
+	return Math.min(range.max, Math.max(range.min, observed));
+}
+
 export function maxBlankLinesBetweenCode(options = {}) {
 	options = normalizeWolframOptions(options);
 	return nonNegativeIntegerOption(
@@ -44,47 +65,72 @@ export function maxBlankLinesBetweenCode(options = {}) {
 }
 
 export function blankLinesBetweenDefinitions(options = {}) {
+	const range = blankLineRangeBetweenDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS),
 	);
 }
 
-function optionalBlankLinesOption(value, fallback) {
+function optionalBlankLineRangeOption(value, fallback) {
 	if (value == null) return fallback;
-	return nonNegativeIntegerOption(value, fallback);
+	return blankLineRangeOption(value, fallback);
 }
 
 export function blankLinesBetweenSetDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetAndSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetAndSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetAndSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSameNameDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSameNameDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSameNameDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenSameNameDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS),
 	);
 }
 
@@ -187,6 +233,48 @@ function blankLinesBetweenDeclarationKinds(
 	return null;
 }
 
+function blankLineRangeBetweenDeclarationKinds(
+	prevKind,
+	nextKind,
+	options,
+	{ requireSpecificOption = false } = {},
+) {
+	if (prevKind === "set" && nextKind === "set") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDefinitions(options);
+	}
+
+	if (prevKind === "setDelayed" && nextKind === "setDelayed") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDelayedDefinitions(options);
+	}
+
+	if (
+		(prevKind === "set" && nextKind === "setDelayed") ||
+		(prevKind === "setDelayed" && nextKind === "set")
+	) {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetAndSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	}
+
+	return null;
+}
+
 function blankLinesBetweenDeclarationNodes(
 	prevNode,
 	nextNode,
@@ -201,6 +289,20 @@ function blankLinesBetweenDeclarationNodes(
 	);
 }
 
+function blankLineRangeBetweenDeclarationNodes(
+	prevNode,
+	nextNode,
+	options,
+	requireSpecificOption = false,
+) {
+	return blankLineRangeBetweenDeclarationKinds(
+		declarationSpacingKind(prevNode),
+		declarationSpacingKind(nextNode),
+		options,
+		{ requireSpecificOption },
+	);
+}
+
 function firstSemanticChild(node) {
 	return semanticChildren(node)[0] ?? null;
 }
@@ -396,14 +498,17 @@ export function blankLinesForCodeGap(
 	if (topLevel && mode === "none") return 0;
 
 	if (hasSharedDefinitionSubject(prevNode, nextNode)) {
-		return blankLinesBetweenSameNameDefinitions(options);
+		return blankLinesFromRange(
+			observedBlankLines,
+			blankLineRangeBetweenSameNameDefinitions(options),
+		);
 	}
 
 	if (isDeclarationNode(prevNode) && isDeclarationNode(nextNode)) {
-		return (
-			blankLinesBetweenDeclarationNodes(prevNode, nextNode, options) ??
-			blankLinesBetweenDefinitions(options)
-		);
+		const range =
+			blankLineRangeBetweenDeclarationNodes(prevNode, nextNode, options) ??
+			blankLineRangeBetweenDefinitions(options);
+		return blankLinesFromRange(observedBlankLines, range);
 	}
 
 	const maxBlankLines = maxBlankLinesBetweenCode(options);