Server IP : 150.95.80.236 / Your IP : 3.23.102.165 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/eslint/lib/rules/ |
Upload File : |
/** * @fileoverview Source code for spaced-comments rule * @author Gyandeep Singh * @deprecated in ESLint v8.53.0 */ "use strict"; const escapeRegExp = require("escape-string-regexp"); const astUtils = require("./utils/ast-utils"); //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ /** * 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(astUtils.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 {import('../shared/types').Rule} */ module.exports = { meta: { deprecated: true, replacedBy: [], type: "suggestion", docs: { description: "Enforce consistent spacing after the `//` or `/*` in a comment", recommended: false, url: "https://eslint.org/docs/latest/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.sourceCode; // 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(), 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, 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(), rule = styleRules[type], 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); } }; } };