eslint-config-bananass
Version:
ESLint Config for Bananass Framework.🍌
410 lines (363 loc) • 12.3 kB
JavaScript
/**
* @fileoverview Source code for spaced-comment rule.
* @license MIT Copied from `eslint` package.
* @see https://github.com/eslint/eslint/blob/v10.0.0/lib/rules/spaced-comment.js
*/
// @ts-nocheck -- TODO: Code was simply copied and pasted. Type annotations will be modified later.
// --------------------------------------------------------------------------------
// Typedef
// --------------------------------------------------------------------------------
/**
* @import { Rule } from 'eslint';
*/
// --------------------------------------------------------------------------------
// Helper
// --------------------------------------------------------------------------------
/**
* Line terminators defined in ECMAScript.
*/
const LINEBREAKS = new Set(['\r\n', '\r', '\n', '\u2028', '\u2029']);
/**
* Escape `RegExp` special characters.
* @license MIT Copied from `escape-string-regexp` package.
* @param {string} string A string to escape.
* @returns {string} An escaped string.
*/
function escapeRegExp(string) {
// Escape characters with special meaning either inside or outside character sets.
// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
}
/**
* Escapes the control characters of a given string.
* @param {string} s A string to escape.
* @returns {string} An escaped string.
*/
function escape(s) {
return `(?:${escapeRegExp(s)})`;
}
/**
* Escapes the control characters of a given string.
* And adds a repeat flag.
* @param {string} s A string to escape.
* @returns {string} An escaped string.
*/
function escapeAndRepeat(s) {
return `${escape(s)}+`;
}
/**
* Parses `markers` option.
* If markers don't include `"*"`, this adds `"*"` to allow JSDoc comments.
* @param {string[]} markers A marker list.
* @returns {string[]} A marker list.
*/
function parseMarkersOption(markers) {
// `*` is a marker for JSDoc comments.
if (!markers.includes('*')) {
return markers.concat('*');
}
return markers;
}
/**
* Creates string pattern for exceptions.
* Generated pattern:
*
* 1. A space or an exception pattern sequence.
* @param {string[]} exceptions An exception pattern list.
* @returns {string} A regular expression string for exceptions.
*/
function createExceptionsPattern(exceptions) {
let pattern = '';
/*
* A space or an exception pattern sequence.
* [] ==> "\s"
* ["-"] ==> "(?:\s|\-+$)"
* ["-", "="] ==> "(?:\s|(?:\-+|=+)$)"
* ["-", "=", "--=="] ==> "(?:\s|(?:\-+|=+|(?:\-\-==)+)$)" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5Cs%7C(%3F%3A%5C-%2B%7C%3D%2B%7C(%3F%3A%5C-%5C-%3D%3D)%2B)%24)
*/
if (exceptions.length === 0) {
// a space.
pattern += '\\s';
} else {
// a space or...
pattern += '(?:\\s|';
if (exceptions.length === 1) {
// a sequence of the exception pattern.
pattern += escapeAndRepeat(exceptions[0]);
} else {
// a sequence of one of the exception patterns.
pattern += '(?:';
pattern += exceptions.map(escapeAndRepeat).join('|');
pattern += ')';
}
pattern += `(?:$|[${Array.from(LINEBREAKS).join('')}]))`;
}
return pattern;
}
/**
* Creates RegExp object for `always` mode.
* Generated pattern for beginning of comment:
*
* 1. First, a marker or nothing.
* 2. Next, a space or an exception pattern sequence.
* @param {string[]} markers A marker list.
* @param {string[]} exceptions An exception pattern list.
* @returns {RegExp} A RegExp object for the beginning of a comment in `always` mode.
*/
function createAlwaysStylePattern(markers, exceptions) {
let pattern = '^';
/*
* A marker or nothing.
* ["*"] ==> "\*?"
* ["*", "!"] ==> "(?:\*|!)?"
* ["*", "/", "!<"] ==> "(?:\*|\/|(?:!<))?" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5C*%7C%5C%2F%7C(%3F%3A!%3C))%3F
*/
if (markers.length === 1) {
// the marker.
pattern += escape(markers[0]);
} else {
// one of markers.
pattern += '(?:';
pattern += markers.map(escape).join('|');
pattern += ')';
}
pattern += '?'; // or nothing.
pattern += createExceptionsPattern(exceptions);
return new RegExp(pattern, 'u');
}
/**
* Creates RegExp object for `never` mode.
* Generated pattern for beginning of comment:
*
* 1. First, a marker or nothing (captured).
* 2. Next, a space or a tab.
* @param {string[]} markers A marker list.
* @returns {RegExp} A RegExp object for `never` mode.
*/
function createNeverStylePattern(markers) {
const pattern = `^(${markers.map(escape).join('|')})?[ \t]+`;
return new RegExp(pattern, 'u');
}
// --------------------------------------------------------------------------------
// Rule Definition
// --------------------------------------------------------------------------------
/** @type {Rule.RuleModule} */
export default {
meta: {
type: 'suggestion',
docs: {
description: 'Enforce consistent spacing after the `//` or `/*` in a comment',
recommended: false,
url: 'https://eslint.style/rules/spaced-comment',
},
fixable: 'whitespace',
schema: [
{
enum: ['always', 'never'],
},
{
type: 'object',
properties: {
exceptions: {
type: 'array',
items: {
type: 'string',
},
},
markers: {
type: 'array',
items: {
type: 'string',
},
},
line: {
type: 'object',
properties: {
exceptions: {
type: 'array',
items: {
type: 'string',
},
},
markers: {
type: 'array',
items: {
type: 'string',
},
},
},
additionalProperties: false,
},
block: {
type: 'object',
properties: {
exceptions: {
type: 'array',
items: {
type: 'string',
},
},
markers: {
type: 'array',
items: {
type: 'string',
},
},
balanced: {
type: 'boolean',
default: false,
},
},
additionalProperties: false,
},
},
additionalProperties: false,
},
],
messages: {
unexpectedSpaceAfterMarker:
'Unexpected space or tab after marker ({{refChar}}) in comment.',
expectedExceptionAfter:
"Expected exception block, space or tab after '{{refChar}}' in comment.",
unexpectedSpaceBefore: "Unexpected space or tab before '*/' in comment.",
unexpectedSpaceAfter: "Unexpected space or tab after '{{refChar}}' in comment.",
expectedSpaceBefore: "Expected space or tab before '*/' in comment.",
expectedSpaceAfter: "Expected space or tab after '{{refChar}}' in comment.",
},
},
create(context) {
const { sourceCode } = context;
// Unless the first option is never, require a space
const requireSpace = context.options[0] !== 'never';
/*
* Parse the second options.
* If markers don't include `"*"`, it's added automatically for JSDoc
* comments.
*/
const config = context.options[1] || {};
const balanced = config.block && config.block.balanced;
const styleRules = ['block', 'line'].reduce((rule, type) => {
const markers = parseMarkersOption(
(config[type] && config[type].markers) || config.markers || [],
);
const exceptions =
(config[type] && config[type].exceptions) || config.exceptions || [];
const endNeverPattern = '[ \t]+$';
// Create RegExp object for valid patterns.
rule[type] = {
beginRegex: requireSpace
? createAlwaysStylePattern(markers, exceptions)
: createNeverStylePattern(markers),
endRegex:
balanced && requireSpace
? new RegExp(`${createExceptionsPattern(exceptions)}$`, 'u')
: new RegExp(endNeverPattern, 'u'),
hasExceptions: exceptions.length > 0,
captureMarker: new RegExp(`^(${markers.map(escape).join('|')})`, 'u'),
markers: new Set(markers),
};
return rule;
}, {});
/**
* Reports a beginning spacing error with an appropriate message.
* @param {ASTNode} node A comment node to check.
* @param {string} messageId An error message to report.
* @param {Array} match An array of match results for markers.
* @param {string} refChar Character used for reference in the error message.
* @returns {void}
*/
function reportBegin(node, messageId, match, refChar) {
const type = node.type.toLowerCase();
const commentIdentifier = type === 'block' ? '/*' : '//';
context.report({
node,
fix(fixer) {
const start = node.range[0];
let end = start + 2;
if (requireSpace) {
if (match) {
end += match[0].length;
}
return fixer.insertTextAfterRange([start, end], ' ');
}
end += match[0].length;
return fixer.replaceTextRange(
[start, end],
commentIdentifier + (match[1] ? match[1] : ''),
);
},
messageId,
data: { refChar },
});
}
/**
* Reports an ending spacing error with an appropriate message.
* @param {ASTNode} node A comment node to check.
* @param {string} messageId An error message to report.
* @param {string} match An array of the matched whitespace characters.
* @returns {void}
*/
function reportEnd(node, messageId, match) {
context.report({
node,
fix(fixer) {
if (requireSpace) {
return fixer.insertTextAfterRange([node.range[0], node.range[1] - 2], ' ');
}
const end = node.range[1] - 2;
const start = end - match[0].length;
return fixer.replaceTextRange([start, end], '');
},
messageId,
});
}
/**
* Reports a given comment if it's invalid.
* @param {ASTNode} node a comment node to check.
* @returns {void}
*/
function checkCommentForSpace(node) {
const type = node.type.toLowerCase();
const rule = styleRules[type];
const commentIdentifier = type === 'block' ? '/*' : '//';
// Ignores empty comments and comments that consist only of a marker.
if (node.value.length === 0 || rule.markers.has(node.value)) {
return;
}
const beginMatch = rule.beginRegex.exec(node.value);
const endMatch = rule.endRegex.exec(node.value);
// Checks.
if (requireSpace) {
if (!beginMatch) {
const hasMarker = rule.captureMarker.exec(node.value);
const marker = hasMarker ? commentIdentifier + hasMarker[0] : commentIdentifier;
if (rule.hasExceptions) {
reportBegin(node, 'expectedExceptionAfter', hasMarker, marker);
} else {
reportBegin(node, 'expectedSpaceAfter', hasMarker, marker);
}
}
if (balanced && type === 'block' && !endMatch) {
reportEnd(node, 'expectedSpaceBefore');
}
} else {
if (beginMatch) {
if (!beginMatch[1]) {
reportBegin(node, 'unexpectedSpaceAfter', beginMatch, commentIdentifier);
} else {
reportBegin(node, 'unexpectedSpaceAfterMarker', beginMatch, beginMatch[1]);
}
}
if (balanced && type === 'block' && endMatch) {
reportEnd(node, 'unexpectedSpaceBefore', endMatch);
}
}
}
return {
Program() {
const comments = sourceCode.getAllComments();
comments.filter(token => token.type !== 'Shebang').forEach(checkCommentForSpace);
},
};
},
};