@cjser/eslint-node-test 0.2.0-cjser.2

package/rules/ast/index.js

@@ -0,0 +1,17 @@
+export {
+	isLiteral,
+	isStringExpression,
+	isBooleanLiteral,
+	getStaticStringValue,
+	isRegexLiteral,
+} from './literal.js';
+
+export {isCallExpression} from './call-or-new-expression.js';
+
+export {default as isExpressionStatement} from './is-expression-statement.js';
+export {default as isFunction} from './is-function.js';
+export {default as isLoop} from './is-loop.js';
+export {default as isMemberExpression} from './is-member-expression.js';
+export {default as isMethodCall} from './is-method-call.js';
+export {default as functionTypes} from './function-types.js';
+export {default as loopTypes} from './loop-types.js';

package/rules/ast/is-expression-statement.js

@@ -0,0 +1,7 @@
+export default function isExpressionStatement(node) {
+	return node.type === 'ExpressionStatement'
+		|| (
+			node.type === 'ChainExpression'
+			&& node.parent.type === 'ExpressionStatement'
+		);
+}

package/rules/ast/is-function.js

@@ -0,0 +1,5 @@
+import functionTypes from './function-types.js';
+
+export default function isFunction(node) {
+	return functionTypes.includes(node.type);
+}

package/rules/ast/is-loop.js

@@ -0,0 +1,5 @@
+import loopTypes from './loop-types.js';
+
+export default function isLoop(node) {
+	return loopTypes.includes(node.type);
+}

package/rules/ast/is-member-expression.js

@@ -0,0 +1,92 @@
+/* eslint-disable complexity */
+/**
+@param {
+	{
+		property?: string,
+		properties?: string[],
+		object?: string,
+		objects?: string[],
+		optional?: boolean,
+		computed?: boolean
+	} | string | string[]
+} [options]
+@returns {string}
+*/
+export default function isMemberExpression(node, options) {
+	if (node?.type !== 'MemberExpression') {
+		return false;
+	}
+
+	if (typeof options === 'string') {
+		options = {properties: [options]};
+	}
+
+	if (Array.isArray(options)) {
+		options = {properties: options};
+	}
+
+	let {
+		property,
+		properties,
+		object,
+		objects,
+		optional,
+		computed,
+	} = {
+		property: '',
+		properties: [],
+		object: '',
+		...options,
+	};
+
+	if (property) {
+		properties = [property];
+	}
+
+	if (object) {
+		objects = [object];
+	}
+
+	if (
+		(optional === true && (node.optional !== optional))
+		|| (
+			optional === false
+			// `node.optional` can be `undefined` in some parsers
+			&& node.optional
+		)
+	) {
+		return false;
+	}
+
+	if (
+		Array.isArray(properties)
+		&& properties.length > 0
+	) {
+		if (
+			node.property.type !== 'Identifier'
+			|| !properties.includes(node.property.name)
+		) {
+			return false;
+		}
+
+		computed ??= false;
+	}
+
+	if (
+		(computed === true && (node.computed !== computed))
+		|| (
+			computed === false
+			// `node.computed` can be `undefined` in some parsers
+			&& node.computed
+		)
+	) {
+		return false;
+	}
+
+	return !(Array.isArray(objects)
+		&& objects.length > 0
+		&& (
+			node.object.type !== 'Identifier'
+			|| !objects.includes(node.object.name)
+		));
+}

package/rules/ast/is-method-call.js

@@ -0,0 +1,62 @@
+import isMemberExpression from './is-member-expression.js';
+import {isCallExpression} from './call-or-new-expression.js';
+
+/**
+@param {
+	{
+		// `isCallExpression` options
+		argumentsLength?: number,
+		minimumArguments?: number,
+		maximumArguments?: number,
+		optionalCall?: boolean,
+		allowSpreadElement?: boolean,
+
+		// `isMemberExpression` options
+		method?: string,
+		methods?: string[],
+		object?: string,
+		objects?: string[],
+		optionalMember?: boolean,
+		computed?: boolean
+	} | string | string[]
+} [options]
+@returns {string}
+*/
+export default function isMethodCall(node, options) {
+	if (typeof options === 'string') {
+		options = {methods: [options]};
+	}
+
+	if (Array.isArray(options)) {
+		options = {methods: options};
+	}
+
+	const {
+		optionalCall,
+		optionalMember,
+		method,
+		methods,
+	} = {
+		method: '',
+		methods: [],
+		...options,
+	};
+
+	return (
+		isCallExpression(node, {
+			argumentsLength: options.argumentsLength,
+			minimumArguments: options.minimumArguments,
+			maximumArguments: options.maximumArguments,
+			allowSpreadElement: options.allowSpreadElement,
+			optional: optionalCall,
+		})
+		&& isMemberExpression(node.callee, {
+			object: options.object,
+			objects: options.objects,
+			computed: options.computed,
+			property: method,
+			properties: methods,
+			optional: optionalMember,
+		})
+	);
+}

package/rules/ast/literal.js

@@ -0,0 +1,32 @@
+export function isLiteral(node, value) {
+	if (node?.type !== 'Literal') {
+		return false;
+	}
+
+	return node.value === value;
+}
+
+const isStringLiteral = node => node?.type === 'Literal' && typeof node.value === 'string';
+
+// A node whose value is always a string: a string literal or any template literal.
+export const isStringExpression = node => isStringLiteral(node) || node?.type === 'TemplateLiteral';
+
+export const isBooleanLiteral = (node, value) =>
+	node?.type === 'Literal'
+	&& typeof node.value === 'boolean'
+	&& (value === undefined || node.value === value);
+
+export const getStaticStringValue = node => {
+	if (isStringLiteral(node)) {
+		return node.value;
+	}
+
+	if (
+		node?.type === 'TemplateLiteral'
+		&& node.expressions.length === 0
+	) {
+		return node.quasis[0].value.cooked;
+	}
+};
+
+export const isRegexLiteral = node => node.type === 'Literal' && Boolean(node.regex);

package/rules/ast/loop-types.js

@@ -0,0 +1,9 @@
+const loopTypes = [
+	'DoWhileStatement',
+	'ForInStatement',
+	'ForOfStatement',
+	'ForStatement',
+	'WhileStatement',
+];
+
+export default loopTypes;

package/rules/consistent-assert-style.js

@@ -0,0 +1,169 @@
+import {isParenthesized} from './utils/index.js';
+
+const MESSAGE_ID = 'consistent-assert-style';
+
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{expected}}` over `{{actual}}`.',
+};
+
+const ASSERT_MODULES = new Set(['node:assert', 'node:assert/strict', 'assert', 'assert/strict']);
+
+function isValueImport(node) {
+	return node.importKind === undefined || node.importKind === 'value';
+}
+
+function isCallableAssertSpecifier(specifier) {
+	if (!isValueImport(specifier)) {
+		return false;
+	}
+
+	if (specifier.type === 'ImportDefaultSpecifier') {
+		return true;
+	}
+
+	if (
+		specifier.type !== 'ImportSpecifier'
+		|| specifier.imported.type !== 'Identifier'
+	) {
+		return false;
+	}
+
+	return specifier.imported.name === 'default'
+		|| specifier.imported.name === 'strict';
+}
+
+function getCallableAssertReferences(context) {
+	const {sourceCode} = context;
+	const references = new Set();
+
+	for (const node of sourceCode.ast.body) {
+		if (
+			node.type !== 'ImportDeclaration'
+			|| typeof node.source.value !== 'string'
+			|| !ASSERT_MODULES.has(node.source.value)
+			|| !isValueImport(node)
+		) {
+			continue;
+		}
+
+		for (const specifier of node.specifiers) {
+			addCallableAssertReferences(sourceCode, specifier, references);
+		}
+	}
+
+	return references;
+}
+
+function addCallableAssertReferences(sourceCode, specifier, references) {
+	if (!isCallableAssertSpecifier(specifier)) {
+		return;
+	}
+
+	const [variable] = sourceCode.getDeclaredVariables(specifier);
+	if (!variable) {
+		return;
+	}
+
+	for (const reference of variable.references) {
+		references.add(reference.identifier);
+	}
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const {style} = context.options[0];
+	const callableAssertReferences = getCallableAssertReferences(context);
+
+	if (callableAssertReferences.size === 0) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const {callee} = node;
+
+		if (style === 'assert-ok') {
+			if (
+				node.optional
+				|| callee.type !== 'Identifier'
+				|| isParenthesized(callee, context)
+				|| !callableAssertReferences.has(callee)
+			) {
+				return;
+			}
+
+			return {
+				node: callee,
+				messageId: MESSAGE_ID,
+				data: {
+					expected: `${callee.name}.ok(…)`,
+					actual: `${callee.name}(…)`,
+				},
+				fix: fixer => fixer.insertTextAfter(callee, '.ok'),
+			};
+		}
+
+		if (
+			node.optional
+			|| callee.type !== 'MemberExpression'
+			|| isParenthesized(callee, context)
+			|| callee.optional
+			|| callee.computed
+			|| callee.object.type !== 'Identifier'
+			|| callee.property.type !== 'Identifier'
+			|| callee.property.name !== 'ok'
+			|| isParenthesized(callee.object, context)
+			|| !callableAssertReferences.has(callee.object)
+		) {
+			return;
+		}
+
+		const problem = {
+			node: callee.property,
+			messageId: MESSAGE_ID,
+			data: {
+				expected: `${callee.object.name}(…)`,
+				actual: `${callee.object.name}.ok(…)`,
+			},
+		};
+
+		if (sourceCode.getCommentsInside(callee).length === 0) {
+			problem.fix = fixer => fixer.removeRange([
+				sourceCode.getRange(callee.object)[1],
+				sourceCode.getRange(callee.property)[1],
+			]);
+		}
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce a consistent truthiness assertion style.',
+			recommended: true,
+		},
+		fixable: 'code',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					style: {
+						enum: ['assert', 'assert-ok'],
+						description: 'Whether truthiness assertions should use `assert(…)` or `assert.ok(…)`.',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{style: 'assert-ok'}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;

package/rules/consistent-assert-throws-callback-style.js

@@ -0,0 +1,241 @@
+import {
+	resolveImports,
+	parseAssertionCall,
+	createContextTracker,
+	isAssertionCallWithSupportedContext,
+} from './utils/node-test.js';
+import {
+	isParenthesized,
+	getParentheses,
+	getParenthesizedRange,
+	unwrapTypeScriptExpression,
+} from './utils/index.js';
+
+const MESSAGE_ID_PREFER_BLOCK = 'consistent-assert-throws-callback-style/prefer-block';
+const MESSAGE_ID_PREFER_EXPRESSION = 'consistent-assert-throws-callback-style/prefer-expression';
+
+const messages = {
+	[MESSAGE_ID_PREFER_BLOCK]: 'Use a block body for the `assert.throws()` callback.',
+	[MESSAGE_ID_PREFER_EXPRESSION]: 'Use an expression body for the `assert.throws()` callback.',
+};
+
+const expressionStatementUnsafeTypes = new Set([
+	'AssignmentExpression',
+	'ClassExpression',
+	'FunctionExpression',
+	'ObjectExpression',
+]);
+
+const arrowExpressionBodyUnsafeTypes = new Set([
+	...expressionStatementUnsafeTypes,
+	'SequenceExpression',
+]);
+
+function getLineIndentation(sourceCode, node) {
+	return sourceCode.lines[sourceCode.getLoc(node).start.line - 1].match(/^\s*/)[0];
+}
+
+function getLeadingComments(sourceCode, node, context) {
+	const [openingParenthesis] = getParentheses(node, context);
+	const target = openingParenthesis ?? node;
+	const previousToken = sourceCode.getTokenBefore(target);
+	if (!previousToken) {
+		return [];
+	}
+
+	const previousTokenEnd = sourceCode.getRange(previousToken)[1];
+	return sourceCode.getCommentsBefore(target).filter(comment => sourceCode.getRange(comment)[0] > previousTokenEnd);
+}
+
+function hasTrailingComment(sourceCode, node, context) {
+	const parentheses = getParentheses(node, context);
+	const target = parentheses.at(-1) ?? node;
+	const nextToken = sourceCode.getTokenAfter(target, {includeComments: true});
+	return nextToken?.type === 'Block' || nextToken?.type === 'Line';
+}
+
+function getExpressionReplacement(node, context) {
+	const {sourceCode} = context;
+	const isBodyParenthesized = isParenthesized(node, context);
+	const range = isBodyParenthesized ? getParenthesizedRange(node, context) : sourceCode.getRange(node);
+	const [leadingComment] = getLeadingComments(sourceCode, node, context);
+	const [start, end] = leadingComment ? [sourceCode.getRange(leadingComment)[0], range[1]] : range;
+	const text = sourceCode.text.slice(start, end);
+	const unwrappedNode = unwrapTypeScriptExpression(node);
+
+	return {
+		range: [start, end],
+		text: !isBodyParenthesized && expressionStatementUnsafeTypes.has(unwrappedNode.type) ? `(${text})` : text,
+	};
+}
+
+function hasLineCommentInRange(sourceCode, range) {
+	return sourceCode.getAllComments().some(comment => comment.type === 'Line' && sourceCode.getRange(comment)[0] >= range[0] && sourceCode.getRange(comment)[1] <= range[1]);
+}
+
+function isBodyOnSameLine(callback, context) {
+	return context.sourceCode.getLoc(callback.body).start.line === context.sourceCode.getLoc(callback).start.line;
+}
+
+function canFixExpressionCallback(callback, context) {
+	const {sourceCode} = context;
+	if (
+		!isBodyOnSameLine(callback, context)
+		|| callback.async
+		|| callback.returnType
+	) {
+		return false;
+	}
+
+	const replacement = getExpressionReplacement(callback.body, context);
+	return (
+		!hasLineCommentInRange(sourceCode, sourceCode.getRange(replacement))
+		&& !hasTrailingComment(sourceCode, callback.body, context)
+	);
+}
+
+function getSingleExpressionStatement(callback) {
+	if (callback.body.type !== 'BlockStatement' || callback.body.body.length !== 1) {
+		return undefined;
+	}
+
+	const [statement] = callback.body.body;
+	return statement.type === 'ExpressionStatement' ? statement : undefined;
+}
+
+function getExpressionBodyReplacement(statement, context) {
+	const {sourceCode} = context;
+	const {expression} = statement;
+	const text = sourceCode.getText(expression);
+	const unwrappedExpression = unwrapTypeScriptExpression(expression);
+
+	return arrowExpressionBodyUnsafeTypes.has(unwrappedExpression.type) ? `(${text})` : text;
+}
+
+function canFixBlockCallback(callback, context) {
+	const {sourceCode} = context;
+	return (
+		isBodyOnSameLine(callback, context)
+		&& !callback.async
+		&& !callback.returnType
+		&& sourceCode.getCommentsInside(callback.body).length === 0
+	);
+}
+
+function getBlockStyleProblem(callback, context) {
+	if (callback.body.type === 'BlockStatement') {
+		return undefined;
+	}
+
+	const {sourceCode} = context;
+	const problem = {
+		node: callback.body,
+		messageId: MESSAGE_ID_PREFER_BLOCK,
+	};
+
+	if (canFixExpressionCallback(callback, context)) {
+		problem.fix = fixer => {
+			const indentation = getLineIndentation(sourceCode, callback);
+			const replacement = getExpressionReplacement(callback.body, context);
+
+			return fixer.replaceTextRange(
+				sourceCode.getRange(replacement),
+				`{\n${indentation}\t${replacement.text};\n${indentation}}`,
+			);
+		};
+	}
+
+	return problem;
+}
+
+function getExpressionStyleProblem(callback, context) {
+	const statement = getSingleExpressionStatement(callback);
+	if (!statement) {
+		return undefined;
+	}
+
+	const problem = {
+		node: callback.body,
+		messageId: MESSAGE_ID_PREFER_EXPRESSION,
+	};
+
+	if (canFixBlockCallback(callback, context)) {
+		problem.fix = fixer => fixer.replaceText(
+			callback.body,
+			getExpressionBodyReplacement(statement, context),
+		);
+	}
+
+	return problem;
+}
+
+function getProblem(node, context, state) {
+	const {imports, tracker, style} = state;
+	const assertion = parseAssertionCall(node, imports);
+	if (assertion?.method !== 'throws' || !isAssertionCallWithSupportedContext(node, tracker)) {
+		return undefined;
+	}
+
+	const [firstArgument] = node.arguments;
+	const callback = firstArgument && unwrapTypeScriptExpression(firstArgument);
+	if (
+		!callback
+		|| callback.type !== 'ArrowFunctionExpression'
+	) {
+		return undefined;
+	}
+
+	return style === 'block' ? getBlockStyleProblem(callback, context) : getExpressionStyleProblem(callback, context);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isAssertOrTestFile) {
+		return;
+	}
+
+	const tracker = createContextTracker(imports, {trackHooks: true});
+	const {style} = context.options[0];
+	const state = {imports, tracker, style};
+
+	context.on('CallExpression', node => {
+		const problem = getProblem(node, context, state);
+		tracker.update(node);
+		return problem;
+	});
+
+	context.onExit('CallExpression', node => {
+		tracker.leave(node);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce a consistent body style for `assert.throws()` arrow callbacks.',
+			recommended: false,
+		},
+		fixable: 'code',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					style: {
+						enum: ['block', 'expression'],
+						description: 'Whether `assert.throws()` arrow callbacks should use block bodies or expression bodies.',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{style: 'block'}],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;