.config/coc/extensions/node_modules/coc-prettier/node_modules/eslint/lib/rules/max-len.js

   1 /**
   2  * @fileoverview Rule to check for max length on a line.
   3  * @author Matt DuVall <http://www.mattduvall.com>
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Constants
  10 //------------------------------------------------------------------------------
  11
  12 const OPTIONS_SCHEMA = {
  13     type: "object",
  14     properties: {
  15         code: {
  16             type: "integer",
  17             minimum: 0
  18         },
  19         comments: {
  20             type: "integer",
  21             minimum: 0
  22         },
  23         tabWidth: {
  24             type: "integer",
  25             minimum: 0
  26         },
  27         ignorePattern: {
  28             type: "string"
  29         },
  30         ignoreComments: {
  31             type: "boolean"
  32         },
  33         ignoreStrings: {
  34             type: "boolean"
  35         },
  36         ignoreUrls: {
  37             type: "boolean"
  38         },
  39         ignoreTemplateLiterals: {
  40             type: "boolean"
  41         },
  42         ignoreRegExpLiterals: {
  43             type: "boolean"
  44         },
  45         ignoreTrailingComments: {
  46             type: "boolean"
  47         }
  48     },
  49     additionalProperties: false
  50 };
  51
  52 const OPTIONS_OR_INTEGER_SCHEMA = {
  53     anyOf: [
  54         OPTIONS_SCHEMA,
  55         {
  56             type: "integer",
  57             minimum: 0
  58         }
  59     ]
  60 };
  61
  62 //------------------------------------------------------------------------------
  63 // Rule Definition
  64 //------------------------------------------------------------------------------
  65
  66 module.exports = {
  67     meta: {
  68         type: "layout",
  69
  70         docs: {
  71             description: "enforce a maximum line length",
  72             category: "Stylistic Issues",
  73             recommended: false,
  74             url: "https://eslint.org/docs/rules/max-len"
  75         },
  76
  77         schema: [
  78             OPTIONS_OR_INTEGER_SCHEMA,
  79             OPTIONS_OR_INTEGER_SCHEMA,
  80             OPTIONS_SCHEMA
  81         ],
  82         messages: {
  83             max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.",
  84             maxComment: "This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}."
  85         }
  86     },
  87
  88     create(context) {
  89
  90         /*
  91          * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
  92          * - They're matching an entire string that we know is a URI
  93          * - We're matching part of a string where we think there *might* be a URL
  94          * - We're only concerned about URLs, as picking out any URI would cause
  95          *   too many false positives
  96          * - We don't care about matching the entire URL, any small segment is fine
  97          */
  98         const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;
  99
 100         const sourceCode = context.getSourceCode();
 101
 102         /**
 103          * Computes the length of a line that may contain tabs. The width of each
 104          * tab will be the number of spaces to the next tab stop.
 105          * @param {string} line The line.
 106          * @param {int} tabWidth The width of each tab stop in spaces.
 107          * @returns {int} The computed line length.
 108          * @private
 109          */
 110         function computeLineLength(line, tabWidth) {
 111             let extraCharacterCount = 0;
 112
 113             line.replace(/\t/gu, (match, offset) => {
 114                 const totalOffset = offset + extraCharacterCount,
 115                     previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0,
 116                     spaceCount = tabWidth - previousTabStopOffset;
 117
 118                 extraCharacterCount += spaceCount - 1; // -1 for the replaced tab
 119             });
 120             return Array.from(line).length + extraCharacterCount;
 121         }
 122
 123         // The options object must be the last option specified…
 124         const options = Object.assign({}, context.options[context.options.length - 1]);
 125
 126         // …but max code length…
 127         if (typeof context.options[0] === "number") {
 128             options.code = context.options[0];
 129         }
 130
 131         // …and tabWidth can be optionally specified directly as integers.
 132         if (typeof context.options[1] === "number") {
 133             options.tabWidth = context.options[1];
 134         }
 135
 136         const maxLength = typeof options.code === "number" ? options.code : 80,
 137             tabWidth = typeof options.tabWidth === "number" ? options.tabWidth : 4,
 138             ignoreComments = !!options.ignoreComments,
 139             ignoreStrings = !!options.ignoreStrings,
 140             ignoreTemplateLiterals = !!options.ignoreTemplateLiterals,
 141             ignoreRegExpLiterals = !!options.ignoreRegExpLiterals,
 142             ignoreTrailingComments = !!options.ignoreTrailingComments || !!options.ignoreComments,
 143             ignoreUrls = !!options.ignoreUrls,
 144             maxCommentLength = options.comments;
 145         let ignorePattern = options.ignorePattern || null;
 146
 147         if (ignorePattern) {
 148             ignorePattern = new RegExp(ignorePattern, "u");
 149         }
 150
 151         //--------------------------------------------------------------------------
 152         // Helpers
 153         //--------------------------------------------------------------------------
 154
 155         /**
 156          * Tells if a given comment is trailing: it starts on the current line and
 157          * extends to or past the end of the current line.
 158          * @param {string} line The source line we want to check for a trailing comment on
 159          * @param {number} lineNumber The one-indexed line number for line
 160          * @param {ASTNode} comment The comment to inspect
 161          * @returns {boolean} If the comment is trailing on the given line
 162          */
 163         function isTrailingComment(line, lineNumber, comment) {
 164             return comment &&
 165                 (comment.loc.start.line === lineNumber && lineNumber <= comment.loc.end.line) &&
 166                 (comment.loc.end.line > lineNumber || comment.loc.end.column === line.length);
 167         }
 168
 169         /**
 170          * Tells if a comment encompasses the entire line.
 171          * @param {string} line The source line with a trailing comment
 172          * @param {number} lineNumber The one-indexed line number this is on
 173          * @param {ASTNode} comment The comment to remove
 174          * @returns {boolean} If the comment covers the entire line
 175          */
 176         function isFullLineComment(line, lineNumber, comment) {
 177             const start = comment.loc.start,
 178                 end = comment.loc.end,
 179                 isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim();
 180
 181             return comment &&
 182                 (start.line < lineNumber || (start.line === lineNumber && isFirstTokenOnLine)) &&
 183                 (end.line > lineNumber || (end.line === lineNumber && end.column === line.length));
 184         }
 185
 186         /**
 187          * Gets the line after the comment and any remaining trailing whitespace is
 188          * stripped.
 189          * @param {string} line The source line with a trailing comment
 190          * @param {ASTNode} comment The comment to remove
 191          * @returns {string} Line without comment and trailing whitepace
 192          */
 193         function stripTrailingComment(line, comment) {
 194
 195             // loc.column is zero-indexed
 196             return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
 197         }
 198
 199         /**
 200          * Ensure that an array exists at [key] on `object`, and add `value` to it.
 201          * @param {Object} object the object to mutate
 202          * @param {string} key the object's key
 203          * @param {*} value the value to add
 204          * @returns {void}
 205          * @private
 206          */
 207         function ensureArrayAndPush(object, key, value) {
 208             if (!Array.isArray(object[key])) {
 209                 object[key] = [];
 210             }
 211             object[key].push(value);
 212         }
 213
 214         /**
 215          * Retrieves an array containing all strings (" or ') in the source code.
 216          * @returns {ASTNode[]} An array of string nodes.
 217          */
 218         function getAllStrings() {
 219             return sourceCode.ast.tokens.filter(token => (token.type === "String" ||
 220                 (token.type === "JSXText" && sourceCode.getNodeByRangeIndex(token.range[0] - 1).type === "JSXAttribute")));
 221         }
 222
 223         /**
 224          * Retrieves an array containing all template literals in the source code.
 225          * @returns {ASTNode[]} An array of template literal nodes.
 226          */
 227         function getAllTemplateLiterals() {
 228             return sourceCode.ast.tokens.filter(token => token.type === "Template");
 229         }
 230
 231
 232         /**
 233          * Retrieves an array containing all RegExp literals in the source code.
 234          * @returns {ASTNode[]} An array of RegExp literal nodes.
 235          */
 236         function getAllRegExpLiterals() {
 237             return sourceCode.ast.tokens.filter(token => token.type === "RegularExpression");
 238         }
 239
 240
 241         /**
 242          * A reducer to group an AST node by line number, both start and end.
 243          * @param {Object} acc the accumulator
 244          * @param {ASTNode} node the AST node in question
 245          * @returns {Object} the modified accumulator
 246          * @private
 247          */
 248         function groupByLineNumber(acc, node) {
 249             for (let i = node.loc.start.line; i <= node.loc.end.line; ++i) {
 250                 ensureArrayAndPush(acc, i, node);
 251             }
 252             return acc;
 253         }
 254
 255         /**
 256          * Check the program for max length
 257          * @param {ASTNode} node Node to examine
 258          * @returns {void}
 259          * @private
 260          */
 261         function checkProgramForMaxLength(node) {
 262
 263             // split (honors line-ending)
 264             const lines = sourceCode.lines,
 265
 266                 // list of comments to ignore
 267                 comments = ignoreComments || maxCommentLength || ignoreTrailingComments ? sourceCode.getAllComments() : [];
 268
 269             // we iterate over comments in parallel with the lines
 270             let commentsIndex = 0;
 271
 272             const strings = getAllStrings();
 273             const stringsByLine = strings.reduce(groupByLineNumber, {});
 274
 275             const templateLiterals = getAllTemplateLiterals();
 276             const templateLiteralsByLine = templateLiterals.reduce(groupByLineNumber, {});
 277
 278             const regExpLiterals = getAllRegExpLiterals();
 279             const regExpLiteralsByLine = regExpLiterals.reduce(groupByLineNumber, {});
 280
 281             lines.forEach((line, i) => {
 282
 283                 // i is zero-indexed, line numbers are one-indexed
 284                 const lineNumber = i + 1;
 285
 286                 /*
 287                  * if we're checking comment length; we need to know whether this
 288                  * line is a comment
 289                  */
 290                 let lineIsComment = false;
 291                 let textToMeasure;
 292
 293                 /*
 294                  * We can short-circuit the comment checks if we're already out of
 295                  * comments to check.
 296                  */
 297                 if (commentsIndex < comments.length) {
 298                     let comment = null;
 299
 300                     // iterate over comments until we find one past the current line
 301                     do {
 302                         comment = comments[++commentsIndex];
 303                     } while (comment && comment.loc.start.line <= lineNumber);
 304
 305                     // and step back by one
 306                     comment = comments[--commentsIndex];
 307
 308                     if (isFullLineComment(line, lineNumber, comment)) {
 309                         lineIsComment = true;
 310                         textToMeasure = line;
 311                     } else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {
 312                         textToMeasure = stripTrailingComment(line, comment);
 313
 314                         // ignore multiple trailing comments in the same line
 315                         let lastIndex = commentsIndex;
 316
 317                         while (isTrailingComment(textToMeasure, lineNumber, comments[--lastIndex])) {
 318                             textToMeasure = stripTrailingComment(textToMeasure, comments[lastIndex]);
 319                         }
 320                     } else {
 321                         textToMeasure = line;
 322                     }
 323                 } else {
 324                     textToMeasure = line;
 325                 }
 326                 if (ignorePattern && ignorePattern.test(textToMeasure) ||
 327                     ignoreUrls && URL_REGEXP.test(textToMeasure) ||
 328                     ignoreStrings && stringsByLine[lineNumber] ||
 329                     ignoreTemplateLiterals && templateLiteralsByLine[lineNumber] ||
 330                     ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]
 331                 ) {
 332
 333                     // ignore this line
 334                     return;
 335                 }
 336
 337                 const lineLength = computeLineLength(textToMeasure, tabWidth);
 338                 const commentLengthApplies = lineIsComment && maxCommentLength;
 339
 340                 if (lineIsComment && ignoreComments) {
 341                     return;
 342                 }
 343
 344                 if (commentLengthApplies) {
 345                     if (lineLength > maxCommentLength) {
 346                         context.report({
 347                             node,
 348                             loc: { line: lineNumber, column: 0 },
 349                             messageId: "maxComment",
 350                             data: {
 351                                 lineLength,
 352                                 maxCommentLength
 353                             }
 354                         });
 355                     }
 356                 } else if (lineLength > maxLength) {
 357                     context.report({
 358                         node,
 359                         loc: { line: lineNumber, column: 0 },
 360                         messageId: "max",
 361                         data: {
 362                             lineLength,
 363                             maxLength
 364                         }
 365                     });
 366                 }
 367             });
 368         }
 369
 370
 371         //--------------------------------------------------------------------------
 372         // Public API
 373         //--------------------------------------------------------------------------
 374
 375         return {
 376             Program: checkProgramForMaxLength
 377         };
 378
 379     }
 380 };