382 lines
11 KiB
JavaScript
382 lines
11 KiB
JavaScript
/**
|
|
* @fileoverview Comma style - enforces comma styles of two types: last and first
|
|
* @author Vignesh Anand aka vegetableman
|
|
* @deprecated in ESLint v8.53.0
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
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: 'comma-style',
|
|
url: 'https://eslint.style/rules/js/comma-style',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
type: 'layout',
|
|
|
|
docs: {
|
|
description: 'Enforce consistent comma style',
|
|
recommended: false,
|
|
url: 'https://eslint.org/docs/latest/rules/comma-style',
|
|
},
|
|
|
|
fixable: 'code',
|
|
|
|
schema: [
|
|
{
|
|
enum: ['first', 'last'],
|
|
},
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
exceptions: {
|
|
type: 'object',
|
|
additionalProperties: {
|
|
type: 'boolean',
|
|
},
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
|
|
messages: {
|
|
unexpectedLineBeforeAndAfterComma:
|
|
"Bad line breaking before and after ','.",
|
|
expectedCommaFirst: "',' should be placed first.",
|
|
expectedCommaLast: "',' should be placed last.",
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const style = context.options[0] || 'last',
|
|
sourceCode = context.sourceCode;
|
|
const exceptions = {
|
|
ArrayPattern: true,
|
|
ArrowFunctionExpression: true,
|
|
CallExpression: true,
|
|
FunctionDeclaration: true,
|
|
FunctionExpression: true,
|
|
ImportDeclaration: true,
|
|
ObjectPattern: true,
|
|
NewExpression: true,
|
|
};
|
|
|
|
if (
|
|
context.options.length === 2 &&
|
|
Object.hasOwn(context.options[1], 'exceptions')
|
|
) {
|
|
const keys = Object.keys(context.options[1].exceptions);
|
|
|
|
for (let i = 0; i < keys.length; i++) {
|
|
exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Helpers
|
|
//--------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Modified text based on the style
|
|
* @param {string} styleType Style type
|
|
* @param {string} text Source code text
|
|
* @returns {string} modified text
|
|
* @private
|
|
*/
|
|
function getReplacedText(styleType, text) {
|
|
switch (styleType) {
|
|
case 'between':
|
|
return `,${text.replace(astUtils.LINEBREAK_MATCHER, '')}`;
|
|
|
|
case 'first':
|
|
return `${text},`;
|
|
|
|
case 'last':
|
|
return `,${text}`;
|
|
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines the fixer function for a given style.
|
|
* @param {string} styleType comma style
|
|
* @param {ASTNode} previousItemToken The token to check.
|
|
* @param {ASTNode} commaToken The token to check.
|
|
* @param {ASTNode} currentItemToken The token to check.
|
|
* @returns {Function} Fixer function
|
|
* @private
|
|
*/
|
|
function getFixerFunction(
|
|
styleType,
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken
|
|
) {
|
|
const text =
|
|
sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) +
|
|
sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]);
|
|
const range = [previousItemToken.range[1], currentItemToken.range[0]];
|
|
|
|
return function (fixer) {
|
|
return fixer.replaceTextRange(range, getReplacedText(styleType, text));
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Validates the spacing around single items in lists.
|
|
* @param {Token} previousItemToken The last token from the previous item.
|
|
* @param {Token} commaToken The token representing the comma.
|
|
* @param {Token} currentItemToken The first token of the current item.
|
|
* @param {Token} reportItem The item to use when reporting an error.
|
|
* @returns {void}
|
|
* @private
|
|
*/
|
|
function validateCommaItemSpacing(
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken,
|
|
reportItem
|
|
) {
|
|
// if single line
|
|
if (
|
|
astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
|
|
astUtils.isTokenOnSameLine(previousItemToken, commaToken)
|
|
) {
|
|
// do nothing.
|
|
} else if (
|
|
!astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
|
|
!astUtils.isTokenOnSameLine(previousItemToken, commaToken)
|
|
) {
|
|
const comment = sourceCode.getCommentsAfter(commaToken)[0];
|
|
const styleType =
|
|
(
|
|
comment &&
|
|
comment.type === 'Block' &&
|
|
astUtils.isTokenOnSameLine(commaToken, comment)
|
|
) ?
|
|
style
|
|
: 'between';
|
|
|
|
// lone comma
|
|
context.report({
|
|
node: reportItem,
|
|
loc: commaToken.loc,
|
|
messageId: 'unexpectedLineBeforeAndAfterComma',
|
|
fix: getFixerFunction(
|
|
styleType,
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken
|
|
),
|
|
});
|
|
} else if (
|
|
style === 'first' &&
|
|
!astUtils.isTokenOnSameLine(commaToken, currentItemToken)
|
|
) {
|
|
context.report({
|
|
node: reportItem,
|
|
loc: commaToken.loc,
|
|
messageId: 'expectedCommaFirst',
|
|
fix: getFixerFunction(
|
|
style,
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken
|
|
),
|
|
});
|
|
} else if (
|
|
style === 'last' &&
|
|
astUtils.isTokenOnSameLine(commaToken, currentItemToken)
|
|
) {
|
|
context.report({
|
|
node: reportItem,
|
|
loc: commaToken.loc,
|
|
messageId: 'expectedCommaLast',
|
|
fix: getFixerFunction(
|
|
style,
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken
|
|
),
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the comma placement with regards to a declaration/property/element
|
|
* @param {ASTNode} node The binary expression node to check
|
|
* @param {string} property The property of the node containing child nodes.
|
|
* @private
|
|
* @returns {void}
|
|
*/
|
|
function validateComma(node, property) {
|
|
const items = node[property],
|
|
arrayLiteral =
|
|
node.type === 'ArrayExpression' || node.type === 'ArrayPattern';
|
|
|
|
if (items.length > 1 || arrayLiteral) {
|
|
// seed as opening [
|
|
let previousItemToken = sourceCode.getFirstToken(node);
|
|
|
|
items.forEach((item) => {
|
|
const commaToken =
|
|
item ? sourceCode.getTokenBefore(item) : previousItemToken,
|
|
currentItemToken =
|
|
item ?
|
|
sourceCode.getFirstToken(item)
|
|
: sourceCode.getTokenAfter(commaToken),
|
|
reportItem = item || currentItemToken;
|
|
|
|
/*
|
|
* This works by comparing three token locations:
|
|
* - previousItemToken is the last token of the previous item
|
|
* - commaToken is the location of the comma before the current item
|
|
* - currentItemToken is the first token of the current item
|
|
*
|
|
* These values get switched around if item is undefined.
|
|
* previousItemToken will refer to the last token not belonging
|
|
* to the current item, which could be a comma or an opening
|
|
* square bracket. currentItemToken could be a comma.
|
|
*
|
|
* All comparisons are done based on these tokens directly, so
|
|
* they are always valid regardless of an undefined item.
|
|
*/
|
|
if (astUtils.isCommaToken(commaToken)) {
|
|
validateCommaItemSpacing(
|
|
previousItemToken,
|
|
commaToken,
|
|
currentItemToken,
|
|
reportItem
|
|
);
|
|
}
|
|
|
|
if (item) {
|
|
const tokenAfterItem = sourceCode.getTokenAfter(
|
|
item,
|
|
astUtils.isNotClosingParenToken
|
|
);
|
|
|
|
previousItemToken =
|
|
tokenAfterItem ?
|
|
sourceCode.getTokenBefore(tokenAfterItem)
|
|
: sourceCode.ast.tokens.at(-1);
|
|
} else {
|
|
previousItemToken = currentItemToken;
|
|
}
|
|
});
|
|
|
|
/*
|
|
* Special case for array literals that have empty last items, such
|
|
* as [ 1, 2, ]. These arrays only have two items show up in the
|
|
* AST, so we need to look at the token to verify that there's no
|
|
* dangling comma.
|
|
*/
|
|
if (arrayLiteral) {
|
|
const lastToken = sourceCode.getLastToken(node),
|
|
nextToLastToken = sourceCode.getTokenBefore(lastToken);
|
|
|
|
if (astUtils.isCommaToken(nextToLastToken)) {
|
|
validateCommaItemSpacing(
|
|
sourceCode.getTokenBefore(nextToLastToken),
|
|
nextToLastToken,
|
|
lastToken,
|
|
lastToken
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Public
|
|
//--------------------------------------------------------------------------
|
|
|
|
const nodes = {};
|
|
|
|
if (!exceptions.VariableDeclaration) {
|
|
nodes.VariableDeclaration = function (node) {
|
|
validateComma(node, 'declarations');
|
|
};
|
|
}
|
|
if (!exceptions.ObjectExpression) {
|
|
nodes.ObjectExpression = function (node) {
|
|
validateComma(node, 'properties');
|
|
};
|
|
}
|
|
if (!exceptions.ObjectPattern) {
|
|
nodes.ObjectPattern = function (node) {
|
|
validateComma(node, 'properties');
|
|
};
|
|
}
|
|
if (!exceptions.ArrayExpression) {
|
|
nodes.ArrayExpression = function (node) {
|
|
validateComma(node, 'elements');
|
|
};
|
|
}
|
|
if (!exceptions.ArrayPattern) {
|
|
nodes.ArrayPattern = function (node) {
|
|
validateComma(node, 'elements');
|
|
};
|
|
}
|
|
if (!exceptions.FunctionDeclaration) {
|
|
nodes.FunctionDeclaration = function (node) {
|
|
validateComma(node, 'params');
|
|
};
|
|
}
|
|
if (!exceptions.FunctionExpression) {
|
|
nodes.FunctionExpression = function (node) {
|
|
validateComma(node, 'params');
|
|
};
|
|
}
|
|
if (!exceptions.ArrowFunctionExpression) {
|
|
nodes.ArrowFunctionExpression = function (node) {
|
|
validateComma(node, 'params');
|
|
};
|
|
}
|
|
if (!exceptions.CallExpression) {
|
|
nodes.CallExpression = function (node) {
|
|
validateComma(node, 'arguments');
|
|
};
|
|
}
|
|
if (!exceptions.ImportDeclaration) {
|
|
nodes.ImportDeclaration = function (node) {
|
|
validateComma(node, 'specifiers');
|
|
};
|
|
}
|
|
if (!exceptions.NewExpression) {
|
|
nodes.NewExpression = function (node) {
|
|
validateComma(node, 'arguments');
|
|
};
|
|
}
|
|
|
|
return nodes;
|
|
},
|
|
};
|