%PDF-
%PDF-
Mini Shell
Mini Shell
/**
* @fileoverview This rule should require or disallow spaces before or after unary operations.
* @author Marcin Kumorek
* @deprecated in ESLint v8.53.0
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
deprecated: {
message: "Formatting rules are being moved out of ESLint core.",
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
deprecatedSince: "8.53.0",
availableUntil: "10.0.0",
replacedBy: [
{
message:
"ESLint Stylistic now maintains deprecated stylistic core rules.",
url: "https://eslint.style/guide/migration",
plugin: {
name: "@stylistic/eslint-plugin-js",
url: "https://eslint.style/packages/js",
},
rule: {
name: "space-unary-ops",
url: "https://eslint.style/rules/js/space-unary-ops",
},
},
],
},
type: "layout",
docs: {
description:
"Enforce consistent spacing before or after unary operators",
recommended: false,
url: "https://eslint.org/docs/latest/rules/space-unary-ops",
},
fixable: "whitespace",
schema: [
{
type: "object",
properties: {
words: {
type: "boolean",
default: true,
},
nonwords: {
type: "boolean",
default: false,
},
overrides: {
type: "object",
additionalProperties: {
type: "boolean",
},
},
},
additionalProperties: false,
},
],
messages: {
unexpectedBefore:
"Unexpected space before unary operator '{{operator}}'.",
unexpectedAfter:
"Unexpected space after unary operator '{{operator}}'.",
unexpectedAfterWord:
"Unexpected space after unary word operator '{{word}}'.",
wordOperator:
"Unary word operator '{{word}}' must be followed by whitespace.",
operator:
"Unary operator '{{operator}}' must be followed by whitespace.",
beforeUnaryExpressions:
"Space is required before unary expressions '{{token}}'.",
},
},
create(context) {
const options = context.options[0] || { words: true, nonwords: false };
const sourceCode = context.sourceCode;
//--------------------------------------------------------------------------
// Helpers
//--------------------------------------------------------------------------
/**
* Check if the node is the first "!" in a "!!" convert to Boolean expression
* @param {ASTnode} node AST node
* @returns {boolean} Whether or not the node is first "!" in "!!"
*/
function isFirstBangInBangBangExpression(node) {
return (
node &&
node.type === "UnaryExpression" &&
node.argument.operator === "!" &&
node.argument &&
node.argument.type === "UnaryExpression" &&
node.argument.operator === "!"
);
}
/**
* Checks if an override exists for a given operator.
* @param {string} operator Operator
* @returns {boolean} Whether or not an override has been provided for the operator
*/
function overrideExistsForOperator(operator) {
return (
options.overrides && Object.hasOwn(options.overrides, operator)
);
}
/**
* Gets the value that the override was set to for this operator
* @param {string} operator Operator
* @returns {boolean} Whether or not an override enforces a space with this operator
*/
function overrideEnforcesSpaces(operator) {
return options.overrides[operator];
}
/**
* Verify Unary Word Operator has spaces after the word operator
* @param {ASTnode} node AST node
* @param {Object} firstToken first token from the AST node
* @param {Object} secondToken second token from the AST node
* @param {string} word The word to be used for reporting
* @returns {void}
*/
function verifyWordHasSpaces(node, firstToken, secondToken, word) {
if (secondToken.range[0] === firstToken.range[1]) {
context.report({
node,
messageId: "wordOperator",
data: {
word,
},
fix(fixer) {
return fixer.insertTextAfter(firstToken, " ");
},
});
}
}
/**
* Verify Unary Word Operator doesn't have spaces after the word operator
* @param {ASTnode} node AST node
* @param {Object} firstToken first token from the AST node
* @param {Object} secondToken second token from the AST node
* @param {string} word The word to be used for reporting
* @returns {void}
*/
function verifyWordDoesntHaveSpaces(
node,
firstToken,
secondToken,
word,
) {
if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) {
if (secondToken.range[0] > firstToken.range[1]) {
context.report({
node,
messageId: "unexpectedAfterWord",
data: {
word,
},
fix(fixer) {
return fixer.removeRange([
firstToken.range[1],
secondToken.range[0],
]);
},
});
}
}
}
/**
* Check Unary Word Operators for spaces after the word operator
* @param {ASTnode} node AST node
* @param {Object} firstToken first token from the AST node
* @param {Object} secondToken second token from the AST node
* @param {string} word The word to be used for reporting
* @returns {void}
*/
function checkUnaryWordOperatorForSpaces(
node,
firstToken,
secondToken,
word,
) {
if (overrideExistsForOperator(word)) {
if (overrideEnforcesSpaces(word)) {
verifyWordHasSpaces(node, firstToken, secondToken, word);
} else {
verifyWordDoesntHaveSpaces(
node,
firstToken,
secondToken,
word,
);
}
} else if (options.words) {
verifyWordHasSpaces(node, firstToken, secondToken, word);
} else {
verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
}
}
/**
* Verifies YieldExpressions satisfy spacing requirements
* @param {ASTnode} node AST node
* @returns {void}
*/
function checkForSpacesAfterYield(node) {
const tokens = sourceCode.getFirstTokens(node, 3),
word = "yield";
if (!node.argument || node.delegate) {
return;
}
checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], word);
}
/**
* Verifies AwaitExpressions satisfy spacing requirements
* @param {ASTNode} node AwaitExpression AST node
* @returns {void}
*/
function checkForSpacesAfterAwait(node) {
const tokens = sourceCode.getFirstTokens(node, 3);
checkUnaryWordOperatorForSpaces(
node,
tokens[0],
tokens[1],
"await",
);
}
/**
* Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator
* @param {ASTnode} node AST node
* @param {Object} firstToken First token in the expression
* @param {Object} secondToken Second token in the expression
* @returns {void}
*/
function verifyNonWordsHaveSpaces(node, firstToken, secondToken) {
if (node.prefix) {
if (isFirstBangInBangBangExpression(node)) {
return;
}
if (firstToken.range[1] === secondToken.range[0]) {
context.report({
node,
messageId: "operator",
data: {
operator: firstToken.value,
},
fix(fixer) {
return fixer.insertTextAfter(firstToken, " ");
},
});
}
} else {
if (firstToken.range[1] === secondToken.range[0]) {
context.report({
node,
messageId: "beforeUnaryExpressions",
data: {
token: secondToken.value,
},
fix(fixer) {
return fixer.insertTextBefore(secondToken, " ");
},
});
}
}
}
/**
* Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator
* @param {ASTnode} node AST node
* @param {Object} firstToken First token in the expression
* @param {Object} secondToken Second token in the expression
* @returns {void}
*/
function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) {
if (node.prefix) {
if (secondToken.range[0] > firstToken.range[1]) {
context.report({
node,
messageId: "unexpectedAfter",
data: {
operator: firstToken.value,
},
fix(fixer) {
if (
astUtils.canTokensBeAdjacent(
firstToken,
secondToken,
)
) {
return fixer.removeRange([
firstToken.range[1],
secondToken.range[0],
]);
}
return null;
},
});
}
} else {
if (secondToken.range[0] > firstToken.range[1]) {
context.report({
node,
messageId: "unexpectedBefore",
data: {
operator: secondToken.value,
},
fix(fixer) {
return fixer.removeRange([
firstToken.range[1],
secondToken.range[0],
]);
},
});
}
}
}
/**
* Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements
* @param {ASTnode} node AST node
* @returns {void}
*/
function checkForSpaces(node) {
const tokens =
node.type === "UpdateExpression" && !node.prefix
? sourceCode.getLastTokens(node, 2)
: sourceCode.getFirstTokens(node, 2);
const firstToken = tokens[0];
const secondToken = tokens[1];
if (
(node.type === "NewExpression" || node.prefix) &&
firstToken.type === "Keyword"
) {
checkUnaryWordOperatorForSpaces(
node,
firstToken,
secondToken,
firstToken.value,
);
return;
}
const operator = node.prefix ? tokens[0].value : tokens[1].value;
if (overrideExistsForOperator(operator)) {
if (overrideEnforcesSpaces(operator)) {
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
} else {
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
}
} else if (options.nonwords) {
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
} else {
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
}
}
//--------------------------------------------------------------------------
// Public
//--------------------------------------------------------------------------
return {
UnaryExpression: checkForSpaces,
UpdateExpression: checkForSpaces,
NewExpression: checkForSpaces,
YieldExpression: checkForSpacesAfterYield,
AwaitExpression: checkForSpacesAfterAwait,
};
},
};
Zerion Mini Shell 1.0