diff --git a/lib/index.js b/lib/index.js index 6144b38..6df6e45 100644 --- a/lib/index.js +++ b/lib/index.js @@ -17,8 +17,7 @@ var fluentChaining = require('./rules/fluent-chaining'), modulesOnly = require('./rules/module-files-only'), blockScopeCase = require('./rules/block-scope-case'), braceStyle = require('./rules/brace-style'), - maxStatementsPerLine = require('./rules/max-statements-per-line'), - indent = require('./rules/indent'); + maxStatementsPerLine = require('./rules/max-statements-per-line'); module.exports.rules = { 'fluent-chaining': fluentChaining, @@ -27,7 +26,6 @@ module.exports.rules = { 'no-multiple-inline-functions': noMultipleInlineFunctions, 'no-multiline-var-declarations': noMultilineVarDeclaration, 'brace-style': braceStyle, - 'indent': indent, 'no-multiline-conditionals': noMultilineConditionals, 'empty-object-spacing': emptyObjectSpacing, 'empty-array-spacing': emptyArraySpacing, diff --git a/lib/rules/indent.js b/lib/rules/indent.js deleted file mode 100644 index b4b9309..0000000 --- a/lib/rules/indent.js +++ /dev/null @@ -1,1874 +0,0 @@ -/** - * @deprecated - * - * THIS RULE IS NOT MAINTAINED, AND SHOULD NOT BE USED. Our config project has switched - * back to using the default eslint rule because the bugs we found in it were eventually - * fixed. In 3.0.0 of the plugin, we will delete this rule. - * - * Ironically, this rule no longer passes the indentation rules we define in our config, - * and fixing it is not worth the hassle, so we are also disabling the indentation - * checking on this file. - */ - -/* eslint-disable indent */ - -/** -* Forked from: https://github.com/eslint/eslint/blob/v5.10.0/lib/rules/indent.js -* With the following changes applied: https://github.com/eslint/eslint/compare/83017a3..9738f8c -* This modification adds the `VariableDeclaratorOffset` configuration variable -* that allows specifying how many spaces a multi-line variable declaration should -* be offset from the normal indentation level. For example: -* -* var something, -* anotherSomething, -* somethingElse; -* -* The multi-line variable declaration is indented 4 spaces from the normal indentation -* level, so VariableDeclaratorOffset should be set to '1' (i.e. indent of 3, offset adds -* 1, total indent 4). es6 const declarations would need an offset of 3 (indent of 3, -* offset adds 3, total indent 6) to line up. -* -* Example configuration: "silvermine/indent": -* [ -* "error", -* 3, -* { -* "VariableDeclaratorOffset": { "var": 1, "let": 1, "const": 3 }, -* "SwitchCase": 1 -* } -* ] -* -*/ - -'use strict'; - -// ------------------------------------------------------------------------------ -// Requirements -// ------------------------------------------------------------------------------ - -const lodash = require('lodash'); - -const astUtils = require('../helpers/ast-utils'); - -const createTree = require('functional-red-black-tree'); - -// ------------------------------------------------------------------------------ -// Rule Definition -// ------------------------------------------------------------------------------ - -const KNOWN_NODES = new Set([ - 'AssignmentExpression', - 'AssignmentPattern', - 'ArrayExpression', - 'ArrayPattern', - 'ArrowFunctionExpression', - 'AwaitExpression', - 'BlockStatement', - 'BinaryExpression', - 'BreakStatement', - 'CallExpression', - 'CatchClause', - 'ClassBody', - 'ClassDeclaration', - 'ClassExpression', - 'ConditionalExpression', - 'ContinueStatement', - 'DoWhileStatement', - 'DebuggerStatement', - 'EmptyStatement', - 'ExperimentalRestProperty', - 'ExperimentalSpreadProperty', - 'ExpressionStatement', - 'ForStatement', - 'ForInStatement', - 'ForOfStatement', - 'FunctionDeclaration', - 'FunctionExpression', - 'Identifier', - 'IfStatement', - 'Literal', - 'LabeledStatement', - 'LogicalExpression', - 'MemberExpression', - 'MetaProperty', - 'MethodDefinition', - 'NewExpression', - 'ObjectExpression', - 'ObjectPattern', - 'Program', - 'Property', - 'RestElement', - 'ReturnStatement', - 'SequenceExpression', - 'SpreadElement', - 'Super', - 'SwitchCase', - 'SwitchStatement', - 'TaggedTemplateExpression', - 'TemplateElement', - 'TemplateLiteral', - 'ThisExpression', - 'ThrowStatement', - 'TryStatement', - 'UnaryExpression', - 'UpdateExpression', - 'VariableDeclaration', - 'VariableDeclarator', - 'WhileStatement', - 'WithStatement', - 'YieldExpression', - 'JSXFragment', - 'JSXOpeningFragment', - 'JSXClosingFragment', - 'JSXIdentifier', - 'JSXNamespacedName', - 'JSXMemberExpression', - 'JSXEmptyExpression', - 'JSXExpressionContainer', - 'JSXElement', - 'JSXClosingElement', - 'JSXOpeningElement', - 'JSXAttribute', - 'JSXSpreadAttribute', - 'JSXText', - 'ExportDefaultDeclaration', - 'ExportNamedDeclaration', - 'ExportAllDeclaration', - 'ExportSpecifier', - 'ImportDeclaration', - 'ImportSpecifier', - 'ImportDefaultSpecifier', - 'ImportNamespaceSpecifier', - 'ImportExpression', -]); - -/* - * General rule strategy: - * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a - * specified offset from another specified token or to the first column. - * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For - * example, when entering a BlockStatement, offset all of the tokens in the - * BlockStatement by 1 indent level from the opening curly brace of the BlockStatement. - * 3. After traversing the AST, calculate the expected indentation levels of every token - * according to the OffsetStorage container. - * 4. For each line, compare the expected indentation of the first token to the actual - * indentation in the file, and report the token if the two values are not equal. - */ - - -/** - * A mutable balanced binary search tree that stores (key, value) pairs. The keys are - * numeric, and must be unique. This is intended to be a generic wrapper around a balanced - * binary search tree library, so that the underlying implementation can easily be swapped - * out. - */ -class BinarySearchTree { - - /** - * Creates an empty tree - */ - constructor() { - this._rbTree = createTree(); - } - - /** - * Inserts an entry into the tree. - * @param {number} key The entry's key - * @param {*} value The entry's value - * @returns {void} - */ - insert(key, value) { - const iterator = this._rbTree.find(key); - - if (iterator.valid) { - this._rbTree = iterator.update(value); - } else { - this._rbTree = this._rbTree.insert(key, value); - } - } - - /** - * Finds the entry with the largest key less than or equal to the provided key - * @param {number} key The provided key - * @returns {{key: number, value: *}|null} The found entry, or null if no such entry - * exists. - */ - findLe(key) { - const iterator = this._rbTree.le(key); - - return iterator && { key: iterator.key, value: iterator.value }; - } - - /** - * Deletes all of the keys in the interval [start, end) - * @param {number} start The start of the range - * @param {number} end The end of the range - * @returns {void} - */ - deleteRange(start, end) { - - // Exit without traversing the tree if the range has zero size. - if (start === end) { - return; - } - const iterator = this._rbTree.ge(start); - - while (iterator.valid && iterator.key < end) { - this._rbTree = this._rbTree.remove(iterator.key); - iterator.next(); - } - } -} - -/** - * A helper class to get token-based info related to indentation - */ -class TokenInfo { - - /** - * @param {SourceCode} sourceCode A SourceCode object - */ - constructor(sourceCode) { - this.sourceCode = sourceCode; - this.firstTokensByLineNumber = sourceCode.tokensAndComments.reduce((map, token) => { - if (!map.has(token.loc.start.line)) { - map.set(token.loc.start.line, token); - } - if (!map.has(token.loc.end.line) && sourceCode.text.slice(token.range[1] - token.loc.end.column, token.range[1]).trim()) { - map.set(token.loc.end.line, token); - } - - return map; - }, new Map()); - } - - /** - * Gets the first token on a given token's line - * @param {Token|ASTNode} token a node or token - * @returns {Token} The first token on the given line - */ - getFirstTokenOfLine(token) { - return this.firstTokensByLineNumber.get(token.loc.start.line); - } - - /** - * Determines whether a token is the first token in its line - * @param {Token} token The token - * @returns {boolean} `true` if the token is the first on its line - */ - isFirstTokenOfLine(token) { - return this.getFirstTokenOfLine(token) === token; - } - - /** - * Get the actual indent of a token - * @param {Token} token Token to examine. This should be the first token on its line. - * @returns {string} The indentation characters that precede the token - */ - getTokenIndent(token) { - return this.sourceCode.text.slice(token.range[0] - token.loc.start.column, token.range[0]); - } -} - -/** - * A class to store information on desired offsets of tokens from each other - */ -class OffsetStorage { - - /** - * @param {TokenInfo} tokenInfo a TokenInfo instance - * @param {number} indentSize The desired size of each indentation level - * @param {string} indentType The indentation character - */ - constructor(tokenInfo, indentSize, indentType) { - this._tokenInfo = tokenInfo; - this._indentSize = indentSize; - this._indentType = indentType; - - this._tree = new BinarySearchTree(); - this._tree.insert(0, { offset: 0, from: null, force: false }); - - this._lockedFirstTokens = new WeakMap(); - this._desiredIndentCache = new WeakMap(); - this._ignoredTokens = new WeakSet(); - } - - _getOffsetDescriptor(token) { - return this._tree.findLe(token.range[0]).value; - } - - /** - * Sets the offset column of token B to match the offset column of token A. - * **WARNING**: This matches a *column*, even if baseToken is not the first token on - * its line. In most cases, `setDesiredOffset` should be used instead. - * @param {Token} baseToken The first token - * @param {Token} offsetToken The second token, whose offset should be matched to the - * first token - * @returns {void} - */ - matchOffsetOf(baseToken, offsetToken) { - - /* - * lockedFirstTokens is a map from a token whose indentation is controlled by the - * "first" option to the token that it depends on. For example, with the - * `ArrayExpression: first` option, the first token of each element in the array - * after the first will be mapped to the first token of the first element. The - * desired indentation of each of these tokens is computed based on the desired - * indentation of the "first" element, rather than through the normal offset - * mechanism. - */ - this._lockedFirstTokens.set(offsetToken, baseToken); - } - - /** - * Sets the desired offset of a token. - * - * This uses a line-based offset collapsing behavior to handle tokens on the same - * line. - * For example, consider the following two cases: - * - * ( - * [ - * bar - * ] - * ) - * - * ([ - * bar - * ]) - * - * Based on the first case, it's clear that the `bar` token needs to have an offset of - * 1 indent level (4 spaces) from the `[` token, and the `[` token has to have an - * offset of 1 indent level from the `(` token. Since the `(` token is the first on - * its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 - * indent levels (8 spaces) from the start of its line. - * - * However, in the second case `bar` should only be indented by 4 spaces. This is - * because the offset of 1 indent level between the `(` and the `[` tokens gets - * "collapsed" because the two tokens are on the same line. As a result, the `(` token - * is mapped to the `[` token with an offset of 0, and the rule correctly decides that - * `bar` should be indented by 1 indent level from the start of the line. - * - * This is useful because rule listeners can usually just call `setDesiredOffset` for - * all the tokens in the node, without needing to check which lines those tokens are - * on. - * - * Note that since collapsing only occurs when two tokens are on the same line, there - * are a few cases where non-intuitive behavior can occur. For example, consider the - * following cases: - * - * foo( - * ). - * bar( - * baz - * ) - * - * foo( - * ).bar( - * baz - * ) - * - * Based on the first example, it would seem that `bar` should be offset by 1 indent - * level from `foo`, and `baz` should be offset by 1 indent level from `bar`. However, - * this is not correct, because it would result in `baz` being indented by 2 indent - * levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, - * no collapsing would occur). - * - * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset - * `bar` by 1 level from the `)`, and offset the `)` by 0 levels from `foo`. This - * ensures that the offset between `bar` and the `)` are correctly collapsed in the - * second case. - * @param {Token} token The token - * @param {Token} fromToken The token that `token` should be offset from - * @param {number} offset The desired indent level - * @param {number} extraIndent The extra static indent amount to add to desired offset - * @returns {void} - */ - setDesiredOffset(token, fromToken, offset, extraIndent) { - return this.setDesiredOffsets(token.range, fromToken, offset, extraIndent); - } - - /** - * Sets the desired offset of all tokens in a range - * It's common for node listeners in this file to need to apply the same offset to a - * large, contiguous range of tokens. Moreover, the offset of any given token is - * usually updated multiple times (roughly once for each node that contains it). This - * means that the offset of each token is updated O(AST depth) times. - * It would not be performant to store and update the offsets for each token - * independently, because the rule would end up having a time complexity of O(number - * of tokens * AST depth), which is quite slow for large files. - * - * Instead, the offset tree is represented as a collection of contiguous offset ranges - * in a file. For example, the following list could represent the state of the offset - * tree at a given point: - * - * * Tokens starting in the interval [0, 15) are aligned with the beginning of the - * file - * * Tokens starting in the interval [15, 30) are offset by 1 indent level from the - * `bar` token - * * Tokens starting in the interval [30, 43) are offset by 1 indent level from the - * `foo` token - * * Tokens starting in the interval [43, 820) are offset by 2 indent levels from the - * `bar` token - * * Tokens starting in the interval [820, ∞) are offset by 1 indent - * level from the `baz` token - * - * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line - * above would be inserted by using: `setDesiredOffsets([30, 43], fooToken, 1);` - * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= - * token.start < range[1] will have the offset - * applied. - * @param {Token} fromToken The token that this is offset from - * @param {number} offset The desired indent level - * @param {boolean} force `true` if this offset should not use the normal collapsing - * behavior. This should almost always be false. - * @param {number} extraIndent The extra static indent amount to add to desired offset - * @returns {void} - */ - setDesiredOffsets(range, fromToken, offset, force, extraIndent) { - - /* - * Offset ranges are stored as a collection of nodes, where each node maps a - * numeric key to an offset descriptor. The tree for the example above would have - * the following nodes: - * - * * key: 0, value: { offset: 0, from: null } - * * key: 15, value: { offset: 1, from: barToken } - * * key: 30, value: { offset: 1, from: fooToken } - * * key: 43, value: { offset: 2, from: barToken } - * * key: 820, value: { offset: 1, from: bazToken } - * - * To find the offset descriptor for any given token, one needs to find the node - * with the largest key which is <= token.start. To make this operation fast, the - * nodes are stored in a balanced binary search tree indexed by key. - */ - const descriptorToInsert = { offset, from: fromToken, force, extraIndent }; - - const descriptorAfterRange = this._tree.findLe(range[1]).value; - - const fromTokenIsInRange = fromToken && fromToken.range[0] >= range[0] && fromToken.range[1] <= range[1]; - - const fromTokenDescriptor = fromTokenIsInRange && this._getOffsetDescriptor(fromToken); - - // First, remove any existing nodes in the range from the tree. - this._tree.deleteRange(range[0] + 1, range[1]); - - // Insert a new node into the tree for this range - this._tree.insert(range[0], descriptorToInsert); - - /* - * To avoid circular offset dependencies, keep the `fromToken` token mapped to - * whatever it was mapped to previously, even if it's in the current range. - */ - if (fromTokenIsInRange) { - this._tree.insert(fromToken.range[0], fromTokenDescriptor); - this._tree.insert(fromToken.range[1], descriptorToInsert); - } - - /* - * To avoid modifying the offset of tokens after the range, insert another node to - * keep the offset of the following tokens the same as it was before. - */ - this._tree.insert(range[1], descriptorAfterRange); - } - - /** - * Gets the desired indent of a token - * @param {Token} token The token - * @returns {string} The desired indent of the token - */ - getDesiredIndent(token) { - if (!this._desiredIndentCache.has(token)) { - - if (this._ignoredTokens.has(token)) { - - /* - * If the token is ignored, use the actual indent of the token as the - * desired indent. - * This ensures that no errors are reported for this token. - */ - this._desiredIndentCache.set(token, this._tokenInfo.getTokenIndent(token)); - } else if (this._lockedFirstTokens.has(token)) { - const firstToken = this._lockedFirstTokens.get(token); - - this._desiredIndentCache.set( - token, - - // (indentation for the first element's line) - this.getDesiredIndent(this._tokenInfo.getFirstTokenOfLine(firstToken)) + - - // (space between the start of the first element's line and the first - // element) - this._indentType.repeat(firstToken.loc.start.column - this._tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column) - ); - } else { - const offsetInfo = this._getOffsetDescriptor(token); - - const extraIndent = offsetInfo.extraIndent ? offsetInfo.extraIndent : 0; - - const offset = ( - offsetInfo.from && - offsetInfo.from.loc.start.line === token.loc.start.line && - !/^\s*?\n/u.test(token.value) && - !offsetInfo.force - ) ? 0 : offsetInfo.offset * this._indentSize + extraIndent; - - this._desiredIndentCache.set( - token, - (offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : '') + this._indentType.repeat(offset) - ); - } - } - - return this._desiredIndentCache.get(token); - } - - /** - * Ignores a token, preventing it from being reported. - * @param {Token} token The token - * @returns {void} - */ - ignoreToken(token) { - if (this._tokenInfo.isFirstTokenOfLine(token)) { - this._ignoredTokens.add(token); - } - } - - /** - * Gets the first token that the given token's indentation is dependent on - * @param {Token} token The token - * @returns {Token} The token that the given token depends on, or `null` if the given - * token is at the top level - */ - getFirstDependency(token) { - return this._getOffsetDescriptor(token).from; - } -} - -const ELEMENT_LIST_SCHEMA = { - oneOf: [ - { - type: 'integer', - minimum: 0, - }, - { - 'enum': [ 'first', 'off' ], - }, - ], -}; - -module.exports = { - meta: { - type: 'layout', - - docs: { - description: 'enforce consistent indentation', - category: 'Stylistic Issues', - recommended: false, - url: 'https://eslint.org/docs/rules/indent', - }, - - fixable: 'whitespace', - - schema: [ - { - oneOf: [ - { - 'enum': [ 'tab' ], - }, - { - type: 'integer', - minimum: 0, - }, - ], - }, - { - type: 'object', - properties: { - SwitchCase: { - type: 'integer', - minimum: 0, - default: 0, - }, - VariableDeclarator: { - oneOf: [ - ELEMENT_LIST_SCHEMA, - { - type: 'object', - properties: { - var: ELEMENT_LIST_SCHEMA, - let: ELEMENT_LIST_SCHEMA, - const: ELEMENT_LIST_SCHEMA, - }, - additionalProperties: false, - }, - ], - }, - VariableDeclaratorOffset: { - oneOf: [ - { - type: 'integer', - minimum: 0, - }, - { - type: 'object', - properties: { - 'var': { - type: 'integer', - minimum: 0, - }, - 'let': { - type: 'integer', - minimum: 0, - }, - 'const': { - type: 'integer', - minimum: 0, - }, - }, - additionalProperties: false, - }, - ], - }, - outerIIFEBody: { - type: 'integer', - minimum: 0, - }, - MemberExpression: { - oneOf: [ - { - type: 'integer', - minimum: 0, - }, - { - 'enum': [ 'off' ], - }, - ], - }, - FunctionDeclaration: { - type: 'object', - properties: { - parameters: ELEMENT_LIST_SCHEMA, - body: { - type: 'integer', - minimum: 0, - }, - }, - additionalProperties: false, - }, - FunctionExpression: { - type: 'object', - properties: { - parameters: ELEMENT_LIST_SCHEMA, - body: { - type: 'integer', - minimum: 0, - }, - }, - additionalProperties: false, - }, - CallExpression: { - type: 'object', - properties: { - arguments: ELEMENT_LIST_SCHEMA, - }, - additionalProperties: false, - }, - ArrayExpression: ELEMENT_LIST_SCHEMA, - ObjectExpression: ELEMENT_LIST_SCHEMA, - ImportDeclaration: ELEMENT_LIST_SCHEMA, - flatTernaryExpressions: { - type: 'boolean', - default: false, - }, - ignoredNodes: { - type: 'array', - items: { - type: 'string', - not: { - pattern: ':exit$', - }, - }, - }, - ignoreComments: { - type: 'boolean', - default: false, - }, - }, - additionalProperties: false, - }, - ], - messages: { - wrongIndentation: 'Expected indentation of {{expected}} but found {{actual}}.', - }, - }, - - create(context) { - const DEFAULT_VARIABLE_INDENT = 1, - DEFAULT_VARIABLE_STATIC_OFFSET = 0, - DEFAULT_PARAMETER_INDENT = 1, - DEFAULT_FUNCTION_BODY_INDENT = 1; - - let indentType = 'space', - indentSize = 4; - - const options = { - SwitchCase: 0, - VariableDeclarator: { - 'var': DEFAULT_VARIABLE_INDENT, - let: DEFAULT_VARIABLE_INDENT, - 'const': DEFAULT_VARIABLE_INDENT, - }, - VariableDeclaratorOffset: { - 'var': DEFAULT_VARIABLE_STATIC_OFFSET, - let: DEFAULT_VARIABLE_STATIC_OFFSET, - 'const': DEFAULT_VARIABLE_STATIC_OFFSET, - }, - outerIIFEBody: 1, - FunctionDeclaration: { - parameters: DEFAULT_PARAMETER_INDENT, - body: DEFAULT_FUNCTION_BODY_INDENT, - }, - FunctionExpression: { - parameters: DEFAULT_PARAMETER_INDENT, - body: DEFAULT_FUNCTION_BODY_INDENT, - }, - CallExpression: { - arguments: DEFAULT_PARAMETER_INDENT, - }, - MemberExpression: 1, - ArrayExpression: 1, - ObjectExpression: 1, - ImportDeclaration: 1, - flatTernaryExpressions: false, - ignoredNodes: [], - ignoreComments: false, - }; - - if (context.options.length) { - if (context.options[0] === 'tab') { - indentSize = 1; - indentType = 'tab'; - } else { - indentSize = context.options[0]; - indentType = 'space'; - } - - if (context.options[1]) { - Object.assign(options, context.options[1]); - - if (typeof options.VariableDeclarator === 'number' || options.VariableDeclarator === 'first') { - options.VariableDeclarator = { - 'var': options.VariableDeclarator, - let: options.VariableDeclarator, - 'const': options.VariableDeclarator, - }; - } - - if (typeof options.VariableDeclaratorOffset === 'number') { - options.VariableDeclaratorOffset = { - 'var': options.VariableDeclaratorOffset, - let: options.VariableDeclaratorOffset, - 'const': options.VariableDeclaratorOffset, - }; - } - } - } - - const sourceCode = context.getSourceCode(); - - const tokenInfo = new TokenInfo(sourceCode); - - const offsets = new OffsetStorage(tokenInfo, indentSize, indentType === 'space' ? ' ' : '\t'); - - const parameterParens = new WeakSet(); - - /** - * Creates an error message for a line, given the expected/actual indentation. - * @param {int} expectedAmount The expected amount of indentation characters for - * this line - * @param {int} actualSpaces The actual number of indentation spaces that were - * found on this line - * @param {int} actualTabs The actual number of indentation tabs that were found - * on this line - * @returns {string} An error message for this line - */ - function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) { - const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? '' : 's'}`; // e.g. "2 tabs" - - const foundSpacesWord = `space${actualSpaces === 1 ? '' : 's'}`; // e.g. "space" - - const foundTabsWord = `tab${actualTabs === 1 ? '' : 's'}`; // e.g. "tabs" - - let foundStatement; - - if (actualSpaces > 0) { - - /* - * Abbreviate the message if the expected indentation is also spaces. - * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but - * found 2 spaces' - */ - foundStatement = indentType === 'space' ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`; - } else if (actualTabs > 0) { - foundStatement = indentType === 'tab' ? actualTabs : `${actualTabs} ${foundTabsWord}`; - } else { - foundStatement = '0'; - } - - return { - expected: expectedStatement, - actual: foundStatement, - }; - } - - /** - * Reports a given indent violation - * @param {Token} token Token violating the indent rule - * @param {string} neededIndent Expected indentation string - * @returns {void} - */ - function report(token, neededIndent) { - const actualIndent = Array.from(tokenInfo.getTokenIndent(token)); - - const numSpaces = actualIndent.filter((char) => { return char === ' '; }).length; - - const numTabs = actualIndent.filter((char) => { return char === '\t'; }).length; - - context.report({ - node: token, - messageId: 'wrongIndentation', - data: createErrorMessageData(neededIndent.length, numSpaces, numTabs), - loc: { - start: { line: token.loc.start.line, column: 0 }, - end: { line: token.loc.start.line, column: token.loc.start.column }, - }, - fix(fixer) { - const range = [ token.range[0] - token.loc.start.column, token.range[0] ]; - - const newText = neededIndent; - - return fixer.replaceTextRange(range, newText); - }, - }); - } - - /** - * Checks if a token's indentation is correct - * @param {Token} token Token to examine - * @param {string} desiredIndent Desired indentation of the string - * @returns {boolean} `true` if the token's indentation is correct - */ - function validateTokenIndent(token, desiredIndent) { - const indentation = tokenInfo.getTokenIndent(token); - - return indentation === desiredIndent || - // To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed - // spaces and tabs. - indentation.includes(' ') && indentation.includes('\t'); - } - - /** - * Check to see if the node is a file level IIFE - * @param {ASTNode} node The function node to check. - * @returns {boolean} True if the node is the outer IIFE - */ - function isOuterIIFE(node) { - - /* - * Verify that the node is an IIFE - */ - if (!node.parent || node.parent.type !== 'CallExpression' || node.parent.callee !== node) { - return false; - } - - /* - * Navigate legal ancestors to determine whether this IIFE is outer. - * A "legal ancestor" is an expression or statement that causes the function - * to get executed immediately. - * For example, `!(function(){})()` is an outer IIFE even though it is - * preceded by a ! operator. - */ - let statement = node.parent && node.parent.parent; - - function checkStatement(stmt) { - return stmt.type === 'UnaryExpression' && [ '!', '~', '+', '-' ].indexOf(stmt.operator) > -1 || - stmt.type === 'AssignmentExpression' || - stmt.type === 'LogicalExpression' || - stmt.type === 'SequenceExpression' || - stmt.type === 'VariableDeclarator'; - } - - while (checkStatement(statement)) { - statement = statement.parent; - } - - return (statement.type === 'ExpressionStatement' || statement.type === 'VariableDeclaration') && - statement.parent.type === 'Program'; - } - - /** - * Counts the number of linebreaks that follow the last non-whitespace character - * in a string - * @param {string} string The string to check - * @returns {number} The number of JavaScript linebreaks that follow the last - * non-whitespace character, - * or the total number of linebreaks if the string is all whitespace. - */ - function countTrailingLinebreaks(string) { - const trailingWhitespace = string.match(/\s*$/u)[0]; - - const linebreakMatches = trailingWhitespace.match(astUtils.createGlobalLinebreakMatcher()); - - return linebreakMatches === null ? 0 : linebreakMatches.length; - } - - /** - * Check indentation for lists of elements (arrays, objects, function params) - * @param {ASTNode[]} elements List of elements that should be offset - * @param {Token} startToken The start token of the list that element should be - * aligned against, e.g. '[' - * @param {Token} endToken The end token of the list, e.g. ']' - * @param {number|string} offset The amount that the elements should be offset - * @returns {void} - */ - function addElementListIndent(elements, startToken, endToken, offset) { - - /** - * Gets the first token of a given element, including surrounding parentheses. - * @param {ASTNode} element A node in the `elements` list - * @returns {Token} The first token of this element - */ - function getFirstToken(element) { - let token = sourceCode.getTokenBefore(element); - - while (astUtils.isOpeningParenToken(token) && token !== startToken) { - token = sourceCode.getTokenBefore(token); - } - - return sourceCode.getTokenAfter(token); - } - - // Run through all the tokens in the list, and offset them by one indent level - // (mainly for comments, other things will end up overridden) - offsets.setDesiredOffsets( - [ startToken.range[1], endToken.range[0] ], - startToken, - typeof offset === 'number' ? offset : 1 - ); - offsets.setDesiredOffset(endToken, startToken, 0); - - // If the preference is "first" but there is no first element (e.g. sparse arrays - // w/ empty first slot), fall back to 1 level. - if (offset === 'first' && elements.length && !elements[0]) { - return; - } - elements.forEach((element, index) => { - if (!element) { - - // Skip holes in arrays - return; - } - if (offset === 'off') { - - // Ignore the first token of every element if the "off" option is used - offsets.ignoreToken(getFirstToken(element)); - } - - // Offset the following elements correctly relative to the first element - if (index === 0) { - return; - } - if (offset === 'first' && tokenInfo.isFirstTokenOfLine(getFirstToken(element))) { - offsets.matchOffsetOf(getFirstToken(elements[0]), getFirstToken(element)); - } else { - const previousElement = elements[index - 1], - firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement), - previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement), - prevElEndLine = previousElementLastToken.loc.end.line - countTrailingLinebreaks(previousElementLastToken.value); - - if (previousElement && prevElEndLine > startToken.loc.end.line) { - offsets.setDesiredOffsets([ previousElement.range[1], element.range[1] ], firstTokenOfPreviousElement, 0); - } - } - }); - } - - /** - * Check and decide whether to check for indentation for blockless nodes - * Scenarios are for or while statements without braces around them - * @param {ASTNode} node node to examine - * @returns {void} - */ - function addBlocklessNodeIndent(node) { - if (node.type !== 'BlockStatement') { - const lastParentToken = sourceCode.getTokenBefore(node, astUtils.isNotOpeningParenToken); - - let firstBodyToken = sourceCode.getFirstToken(node), - lastBodyToken = sourceCode.getLastToken(node); - - // eslint-disable-next-line max-len - while (astUtils.isOpeningParenToken(sourceCode.getTokenBefore(firstBodyToken)) && astUtils.isClosingParenToken(sourceCode.getTokenAfter(lastBodyToken))) { - firstBodyToken = sourceCode.getTokenBefore(firstBodyToken); - lastBodyToken = sourceCode.getTokenAfter(lastBodyToken); - } - - offsets.setDesiredOffsets([ firstBodyToken.range[0], lastBodyToken.range[1] ], lastParentToken, 1); - - /* - * For blockless nodes with semicolon-first style, don't indent the semicolon. - * e.g. - * if (foo) bar() - * ; [1, 2, 3].map(foo) - */ - const lastToken = sourceCode.getLastToken(node); - - if (node.type !== 'EmptyStatement' && astUtils.isSemicolonToken(lastToken)) { - offsets.setDesiredOffset(lastToken, lastParentToken, 0); - } - } - } - - /** - * Checks the indentation for nodes that are like function calls (`CallExpression` - * and `NewExpression`) - * @param {ASTNode} node A CallExpression or NewExpression node - * @returns {void} - */ - function addFunctionCallIndent(node) { - let openingParen; - - if (node.arguments.length) { - openingParen = sourceCode.getFirstTokenBetween(node.callee, node.arguments[0], astUtils.isOpeningParenToken); - } else { - openingParen = sourceCode.getLastToken(node, 1); - } - const closingParen = sourceCode.getLastToken(node); - - parameterParens.add(openingParen); - parameterParens.add(closingParen); - offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0); - - addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments); - } - - /** - * Checks the indentation of parenthesized values, given a list of tokens in a - * program - * @param {Token[]} tokens A list of tokens - * @returns {void} - */ - function addParensIndent(tokens) { - const parenStack = []; - - const parenPairs = []; - - tokens.forEach((nextToken) => { - - // Accumulate a list of parenthesis pairs - if (astUtils.isOpeningParenToken(nextToken)) { - parenStack.push(nextToken); - } else if (astUtils.isClosingParenToken(nextToken)) { - parenPairs.unshift({ left: parenStack.pop(), right: nextToken }); - } - }); - - parenPairs.forEach((pair) => { - const leftParen = pair.left; - - const rightParen = pair.right; - - // We only want to handle parens around expressions, so exclude parentheses - // that are in function parameters and function call arguments. - if (!parameterParens.has(leftParen) && !parameterParens.has(rightParen)) { - const parenthesizedTokens = new Set(sourceCode.getTokensBetween(leftParen, rightParen)); - - parenthesizedTokens.forEach((token) => { - if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) { - offsets.setDesiredOffset(token, leftParen, 1); - } - }); - } - - offsets.setDesiredOffset(rightParen, leftParen, 0); - }); - } - - /** - * Ignore all tokens within an unknown node whose offset do not depend - * on another token's offset within the unknown node - * @param {ASTNode} node Unknown Node - * @returns {void} - */ - function ignoreNode(node) { - const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true })); - - unknownNodeTokens.forEach((token) => { - if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) { - const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token); - - if (token === firstTokenOfLine) { - offsets.ignoreToken(token); - } else { - offsets.setDesiredOffset(token, firstTokenOfLine, 0); - } - } - }); - } - - /** - * Check whether the given token is on the first line of a statement. - * @param {Token} token The token to check. - * @param {ASTNode} leafNode The expression node that the token belongs directly. - * @returns {boolean} `true` if the token is on the first line of a statement. - */ - function isOnFirstLineOfStatement(token, leafNode) { - let node = leafNode; - - while (node.parent && !node.parent.type.endsWith('Statement') && !node.parent.type.endsWith('Declaration')) { - node = node.parent; - } - node = node.parent; - - return !node || node.loc.start.line === token.loc.start.line; - } - - /** - * Check whether there are any blank (whitespace-only) lines between - * two tokens on separate lines. - * @param {Token} firstToken The first token. - * @param {Token} secondToken The second token. - * @returns {boolean} `true` if the tokens are on separate lines and - * there exists a blank line between them, `false` otherwise. - */ - function hasBlankLinesBetween(firstToken, secondToken) { - const firstTokenLine = firstToken.loc.end.line; - - const secondTokenLine = secondToken.loc.start.line; - - if (firstTokenLine === secondTokenLine || firstTokenLine === secondTokenLine - 1) { - return false; - } - - for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) { - if (!tokenInfo.firstTokensByLineNumber.has(line)) { - return true; - } - } - - return false; - } - - const ignoredNodeFirstTokens = new Set(); - - const baseOffsetListeners = { - 'ArrayExpression, ArrayPattern'(node) { - const openingBracket = sourceCode.getFirstToken(node), - prevToken = lodash.findLast(node.elements) || openingBracket, - closingBracket = sourceCode.getTokenAfter(prevToken, astUtils.isClosingBracketToken); - - addElementListIndent(node.elements, openingBracket, closingBracket, options.ArrayExpression); - }, - - 'ObjectExpression, ObjectPattern'(node) { - const openingCurly = sourceCode.getFirstToken(node); - - const closingCurly = sourceCode.getTokenAfter( - node.properties.length ? node.properties[node.properties.length - 1] : openingCurly, - astUtils.isClosingBraceToken - ); - - addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression); - }, - - ArrowFunctionExpression(node) { - const firstToken = sourceCode.getFirstToken(node); - - if (astUtils.isOpeningParenToken(firstToken)) { - const openingParen = firstToken; - - const closingParen = sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken); - - parameterParens.add(openingParen); - parameterParens.add(closingParen); - addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters); - } - addBlocklessNodeIndent(node.body); - }, - - AssignmentExpression(node) { - const operator = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => { return token.value === node.operator; }); - - offsets.setDesiredOffsets([ operator.range[0], node.range[1] ], sourceCode.getLastToken(node.left), 1); - offsets.ignoreToken(operator); - offsets.ignoreToken(sourceCode.getTokenAfter(operator)); - }, - - 'BinaryExpression, LogicalExpression'(node) { - const operator = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => { return token.value === node.operator; }); - - /* - * For backwards compatibility, don't check BinaryExpression indents, e.g. - * var foo = bar && - * baz; - */ - const tokenAfterOperator = sourceCode.getTokenAfter(operator); - - offsets.ignoreToken(operator); - offsets.ignoreToken(tokenAfterOperator); - offsets.setDesiredOffset(tokenAfterOperator, operator, 0); - }, - - 'BlockStatement, ClassBody'(node) { - - let blockIndentLevel; - - if (node.parent && isOuterIIFE(node.parent)) { - blockIndentLevel = options.outerIIFEBody; - } else if (node.parent && (node.parent.type === 'FunctionExpression' || node.parent.type === 'ArrowFunctionExpression')) { - blockIndentLevel = options.FunctionExpression.body; - } else if (node.parent && node.parent.type === 'FunctionDeclaration') { - blockIndentLevel = options.FunctionDeclaration.body; - } else { - blockIndentLevel = 1; - } - - /* - * For blocks that aren't lone statements, ensure that the opening curly brace - * is aligned with the parent. - */ - if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) { - offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0); - } - addElementListIndent(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel); - }, - - CallExpression: addFunctionCallIndent, - - 'ClassDeclaration[superClass], ClassExpression[superClass]'(node) { - const classToken = sourceCode.getFirstToken(node); - - const extendsToken = sourceCode.getTokenBefore(node.superClass, astUtils.isNotOpeningParenToken); - - offsets.setDesiredOffsets([ extendsToken.range[0], node.body.range[0] ], classToken, 1); - }, - - ConditionalExpression(node) { - const firstToken = sourceCode.getFirstToken(node), - isOnSameLine = !astUtils.isTokenOnSameLine(node.test, node.consequent), - isOnFirstLine = isOnFirstLineOfStatement(firstToken, node); - - // `flatTernaryExpressions` option is for the following style: - // var a = - // foo > 0 ? bar : - // foo < 0 ? baz : - // /*else*/ qiz ; - if (!options.flatTernaryExpressions || isOnSameLine || isOnFirstLine) { - const questionMarkToken = sourceCode.getFirstTokenBetween( - node.test, - node.consequent, - (token) => { return token.type === 'Punctuator' && token.value === '?'; } - ); - - const colonToken = sourceCode.getFirstTokenBetween( - node.consequent, - node.alternate, - (token) => { return token.type === 'Punctuator' && token.value === ':'; } - ); - - const firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken); - - const lastConsequentToken = sourceCode.getTokenBefore(colonToken); - - const firstAlternateToken = sourceCode.getTokenAfter(colonToken); - - offsets.setDesiredOffset(questionMarkToken, firstToken, 1); - offsets.setDesiredOffset(colonToken, firstToken, 1); - - offsets.setDesiredOffset(firstConsequentToken, firstToken, 1); - - /* - * The alternate and the consequent should usually have the same - * indentation. - * If they share part of a line, align the alternate against the first - * token of the consequent. - * This allows the alternate to be indented correctly in cases like this: - * foo ? ( - * bar - * ) : ( // this '(' is aligned with the '(' above, so it's considered to - * // be aligned with `foo` - * baz // as a result, `baz` is offset by 1 rather than 2 - * ) - */ - if (lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line) { - offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0); - } else { - - /** - * If the alternate and consequent do not share part of a line, offset - * the alternate from the first token of the conditional expression. - * For example: - * foo ? bar - * : baz - * - * If `baz` were aligned with `bar` rather than being offset by 1 from - * `foo`, `baz` would end up having no expected indentation. - */ - offsets.setDesiredOffset(firstAlternateToken, firstToken, 1); - } - } - }, - - 'DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement': (node) => { return addBlocklessNodeIndent(node.body); }, - - ExportNamedDeclaration(node) { - if (node.declaration === null) { - const closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken); - - // Indent the specifiers in `export {foo, bar, baz}` - addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1); - - if (node.source) { - - // Indent everything after and including the `from` token in `export - // {foo, bar, baz} from 'qux'` - offsets.setDesiredOffsets([ closingCurly.range[1], node.range[1] ], sourceCode.getFirstToken(node), 1); - } - } - }, - - ForStatement(node) { - const forOpeningParen = sourceCode.getFirstToken(node, 1); - - if (node.init) { - offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1); - } - if (node.test) { - offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1); - } - if (node.update) { - offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1); - } - addBlocklessNodeIndent(node.body); - }, - - 'FunctionDeclaration, FunctionExpression'(node) { - const closingParen = sourceCode.getTokenBefore(node.body); - - const openingParen = sourceCode.getTokenBefore(node.params.length ? node.params[0] : closingParen); - - parameterParens.add(openingParen); - parameterParens.add(closingParen); - addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters); - }, - - IfStatement(node) { - addBlocklessNodeIndent(node.consequent); - if (node.alternate && node.alternate.type !== 'IfStatement') { - addBlocklessNodeIndent(node.alternate); - } - }, - - ImportDeclaration(node) { - if (node.specifiers.some((specifier) => { return specifier.type === 'ImportSpecifier'; })) { - const openingCurly = sourceCode.getFirstToken(node, astUtils.isOpeningBraceToken), - closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken), - nodeSpecifierFilter = (specifier) => { return specifier.type === 'ImportSpecifier'; }; - - addElementListIndent(node.specifiers.filter(nodeSpecifierFilter), openingCurly, closingCurly, options.ImportDeclaration); - } - - const fromToken = sourceCode.getLastToken(node, (token) => { return token.type === 'Identifier' && token.value === 'from'; }); - - const sourceToken = sourceCode.getLastToken(node, (token) => { return token.type === 'String'; }); - - const semiToken = sourceCode.getLastToken(node, (token) => { return token.type === 'Punctuator' && token.value === ';'; }); - - if (fromToken) { - const end = semiToken && semiToken.range[1] === sourceToken.range[1] ? node.range[1] : sourceToken.range[1]; - - offsets.setDesiredOffsets([ fromToken.range[0], end ], sourceCode.getFirstToken(node), 1); - } - }, - - ImportExpression(node) { - const openingParen = sourceCode.getFirstToken(node, 1); - const closingParen = sourceCode.getLastToken(node); - - parameterParens.add(openingParen); - parameterParens.add(closingParen); - offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0); - - addElementListIndent([ node.source ], openingParen, closingParen, options.CallExpression.arguments); - }, - - 'MemberExpression, JSXMemberExpression, MetaProperty'(node) { - const object = node.type === 'MetaProperty' ? node.meta : node.object; - - const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, node.property, astUtils.isNotClosingParenToken); - - const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken); - - const objectParenCount = sourceCode.getTokensBetween(object, node.property, { filter: astUtils.isClosingParenToken }).length; - - const firstObjectToken = objectParenCount - ? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 }) - : sourceCode.getFirstToken(object); - - const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken); - - const firstPropertyToken = node.computed ? firstNonObjectToken : secondNonObjectToken; - - if (node.computed) { - // For computed MemberExpressions, match the closing bracket with the - // opening bracket. - offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0); - offsets.setDesiredOffsets(node.property.range, firstNonObjectToken, 1); - } - - /* - * If the object ends on the same line that the property starts, match against - * the last token of the object, to ensure that the MemberExpression is not - * indented. - * - * Otherwise, match against the first token of the object, e.g. - * foo - * .bar - * .baz // <-- offset by 1 from `foo` - */ - const offsetBase = lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line - ? lastObjectToken - : firstObjectToken; - - if (typeof options.MemberExpression === 'number') { - - // Match the dot (for non-computed properties) or the opening bracket (for - // computed properties) against the object. - offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression); - - /* - * For computed MemberExpressions, match the first token of the property - * against the opening bracket. Otherwise, match the first token of the - * property against the object. - */ - offsets.setDesiredOffset(secondNonObjectToken, node.computed ? firstNonObjectToken : offsetBase, options.MemberExpression); - } else { - - // If the MemberExpression option is off, ignore the dot and the first - // token of the property. - offsets.ignoreToken(firstNonObjectToken); - offsets.ignoreToken(secondNonObjectToken); - - // To ignore the property indentation, ensure that the property tokens - // depend on the ignored tokens. - offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0); - offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0); - } - }, - - NewExpression(node) { - const isClosingParen = astUtils.isClosingParenToken(sourceCode.getLastToken(node)), - isOpeningParen = astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1)); - - // Only indent the arguments if the NewExpression has parens (e.g. `new - // Foo(bar)` or `new Foo()`, but not `new Foo` - if (node.arguments.length > 0 || isClosingParen && isOpeningParen) { - addFunctionCallIndent(node); - } - }, - - Property(node) { - if (!node.shorthand && !node.method && node.kind === 'init') { - const colon = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isColonToken); - - offsets.ignoreToken(sourceCode.getTokenAfter(colon)); - } - }, - - SwitchStatement(node) { - const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken); - - const closingCurly = sourceCode.getLastToken(node); - - offsets.setDesiredOffsets([ openingCurly.range[1], closingCurly.range[0] ], openingCurly, options.SwitchCase); - - if (node.cases.length) { - const tokensBetween = sourceCode.getTokensBetween( - node.cases[node.cases.length - 1], - closingCurly, - { includeComments: true, filter: astUtils.isCommentToken } - ); - - tokensBetween.forEach((token) => { return offsets.ignoreToken(token); }); - } - }, - - SwitchCase(node) { - if (!(node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement')) { - const caseKeyword = sourceCode.getFirstToken(node); - - const tokenAfterCurrentCase = sourceCode.getTokenAfter(node); - - offsets.setDesiredOffsets([ caseKeyword.range[1], tokenAfterCurrentCase.range[0] ], caseKeyword, 1); - } - }, - - TemplateLiteral(node) { - node.expressions.forEach((expression, index) => { - const previousQuasi = node.quasis[index]; - - const nextQuasi = node.quasis[index + 1]; - - const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line - ? sourceCode.getFirstToken(previousQuasi) - : null; - - offsets.setDesiredOffsets([ previousQuasi.range[1], nextQuasi.range[0] ], tokenToAlignFrom, 1); - offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0); - }); - }, - - VariableDeclaration(node) { - let variableIndent; - - variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind) - ? options.VariableDeclarator[node.kind] - : DEFAULT_VARIABLE_INDENT; - - const extraVariableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclaratorOffset, node.kind) - ? options.VariableDeclaratorOffset[node.kind] - : 0; - - const firstToken = sourceCode.getFirstToken(node), - lastToken = sourceCode.getLastToken(node); - - if (options.VariableDeclarator[node.kind] === 'first') { - if (node.declarations.length > 1) { - addElementListIndent( - node.declarations, - firstToken, - lastToken, - 'first' - ); - return; - } - - variableIndent = DEFAULT_VARIABLE_INDENT; - } - - if (node.declarations[node.declarations.length - 1].loc.start.line > node.loc.start.line) { - - /* - * VariableDeclarator indentation is a bit different from other forms of - * indentation, in that the indentation of an opening bracket sometimes - * won't match that of a closing bracket. For example, the following - * indentations are correct: - * - * var foo = { - * ok: true - * }; - * - * var foo = { - * ok: true, - * }, - * bar = 1; - * - * Account for when exiting the AST (after indentations have already been - * set for the nodes in the declaration) by manually increasing the - * indentation level of the tokens in this declarator on the same line as - * the start of the declaration, provided that there are declarators that - * follow this one. - */ - offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true, extraVariableIndent); - } else if (node.loc.start.line === node.loc.end.line) { - - /* Only add the extra space if this declaration doesn't span multiple - * lines. Otherwise, we can't do: - * const myArr [ - * { - * a: 1, - * b: 2, - * }, - * ]; - */ - offsets.setDesiredOffsets(node.range, firstToken, variableIndent, extraVariableIndent); - } else { - offsets.setDesiredOffsets(node.range, firstToken, variableIndent); - } - - if (astUtils.isSemicolonToken(lastToken)) { - offsets.ignoreToken(lastToken); - } - }, - - VariableDeclarator(node) { - if (node.init) { - const equalOperator = sourceCode.getTokenBefore(node.init, astUtils.isNotOpeningParenToken); - - const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator); - - offsets.ignoreToken(equalOperator); - offsets.ignoreToken(tokenAfterOperator); - offsets.setDesiredOffsets([ tokenAfterOperator.range[0], node.range[1] ], equalOperator, 1); - offsets.setDesiredOffset(equalOperator, sourceCode.getLastToken(node.id), 0); - } - }, - - 'JSXAttribute[value]'(node) { - const equalsToken = sourceCode.getFirstTokenBetween( - node.name, - node.value, - (token) => { return token.type === 'Punctuator' && token.value === '='; } - ); - - offsets.setDesiredOffsets([ equalsToken.range[0], node.value.range[1] ], sourceCode.getFirstToken(node.name), 1); - }, - - JSXElement(node) { - if (node.closingElement) { - addElementListIndent( - node.children, - sourceCode.getFirstToken(node.openingElement), - sourceCode.getFirstToken(node.closingElement), - 1 - ); - } - }, - - JSXOpeningElement(node) { - const firstToken = sourceCode.getFirstToken(node); - - let closingToken; - - if (node.selfClosing) { - closingToken = sourceCode.getLastToken(node, { skip: 1 }); - offsets.setDesiredOffset(sourceCode.getLastToken(node), closingToken, 0); - } else { - closingToken = sourceCode.getLastToken(node); - } - offsets.setDesiredOffsets(node.name.range, sourceCode.getFirstToken(node)); - addElementListIndent(node.attributes, firstToken, closingToken, 1); - }, - - JSXClosingElement(node) { - const firstToken = sourceCode.getFirstToken(node); - - offsets.setDesiredOffsets(node.name.range, firstToken, 1); - }, - - JSXFragment(node) { - const firstOpeningToken = sourceCode.getFirstToken(node.openingFragment); - const firstClosingToken = sourceCode.getFirstToken(node.closingFragment); - - addElementListIndent(node.children, firstOpeningToken, firstClosingToken, 1); - }, - - JSXOpeningFragment(node) { - const firstToken = sourceCode.getFirstToken(node); - const closingToken = sourceCode.getLastToken(node); - - offsets.setDesiredOffsets(node.range, firstToken, 1); - offsets.matchOffsetOf(firstToken, closingToken); - }, - - JSXClosingFragment(node) { - const firstToken = sourceCode.getFirstToken(node); - const slashToken = sourceCode.getLastToken(node, { skip: 1 }); - const closingToken = sourceCode.getLastToken(node); - const tokenToMatch = astUtils.isTokenOnSameLine(slashToken, closingToken) ? slashToken : closingToken; - - offsets.setDesiredOffsets(node.range, firstToken, 1); - offsets.matchOffsetOf(firstToken, tokenToMatch); - }, - - JSXExpressionContainer(node) { - const openingCurly = sourceCode.getFirstToken(node); - - const closingCurly = sourceCode.getLastToken(node); - - offsets.setDesiredOffsets([ openingCurly.range[1], closingCurly.range[0] ], openingCurly, 1); - }, - - JSXSpreadAttribute(node) { - const openingCurly = sourceCode.getFirstToken(node); - const closingCurly = sourceCode.getLastToken(node); - - offsets.setDesiredOffsets( - [ openingCurly.range[1], closingCurly.range[0] ], - openingCurly, - 1 - ); - }, - - '*'(node) { - const firstToken = sourceCode.getFirstToken(node); - - // Ensure that the children of every node are indented at least as much as the - // first token. - if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) { - offsets.setDesiredOffsets(node.range, firstToken, 0); - } - }, - }; - - const listenerCallQueue = []; - - /* - * To ignore the indentation of a node: - * 1. Don't call the node's listener when entering it (if it has a listener) - * 2. Don't set any offsets against the first token of the node. - * 3. Call `ignoreNode` on the node sometime after exiting it and before - * validating offsets. - */ - const offsetListeners = lodash.mapValues( - baseOffsetListeners, - - /* - * Offset listener calls are deferred until traversal is finished, and are - * called as part of the final `Program:exit` listener. This is necessary - * because a node might be matched by multiple selectors. - * - * Example: Suppose there is an offset listener for `Identifier`, and the user - * has specified in configuration that `MemberExpression > Identifier` should - * be ignored. Due to selector specificity rules, the `Identifier` listener - * will get called first. However, if a given Identifier node is supposed to - * be ignored, then the `Identifier` offset listener should not have been - * called at all. Without doing extra selector matching, we don't know whether - * the Identifier matches the `MemberExpression > Identifier` selector until - * the `MemberExpression > Identifier` listener is called. - * - * To avoid this, the `Identifier` listener isn't called until traversal - * finishes and all ignored nodes are known. - */ - (listener) => { return (node) => { return listenerCallQueue.push({ listener, node }); }; } - ); - - // For each ignored node selector, set up a listener to collect it into the - // `ignoredNodes` set. - const ignoredNodes = new Set(); - - /** - * Ignores a node - * @param {ASTNode} node The node to ignore - * @returns {void} - */ - function addToIgnoredNodes(node) { - ignoredNodes.add(node); - ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node)); - } - - const ignoredNodeListeners = options.ignoredNodes.reduce( - (listeners, ignoredSelector) => { return Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }); }, - {} - ); - - /* - * Join the listeners, and add a listener to verify that all tokens actually have - * the correct indentation at the end. - * - * Using Object.assign will cause some offset listeners to be overwritten if the - * same selector also appears in `ignoredNodeListeners`. This isn't a problem - * because all of the matching nodes will be ignored, so those listeners wouldn't - * be called anyway. - */ - return Object.assign( - offsetListeners, - ignoredNodeListeners, - { - '*:exit'(node) { - - // If a node's type is nonstandard, we can't tell how its children should - // be offset, so ignore it. - if (!KNOWN_NODES.has(node.type)) { - addToIgnoredNodes(node); - } - }, - 'Program:exit'() { - - // If ignoreComments option is enabled, ignore all comment tokens. - if (options.ignoreComments) { - sourceCode.getAllComments() - .forEach((comment) => { return offsets.ignoreToken(comment); }); - } - - // Invoke the queued offset listeners for the nodes that aren't ignored. - listenerCallQueue - .filter((nodeInfo) => { return !ignoredNodes.has(nodeInfo.node); }) - .forEach((nodeInfo) => { return nodeInfo.listener(nodeInfo.node); }); - - // Update the offsets for ignored nodes to prevent their child tokens from - // being reported. - ignoredNodes.forEach(ignoreNode); - - addParensIndent(sourceCode.ast.tokens); - - /* - * Create a Map from (tokenOrComment) => (precedingToken). - * This is necessary because sourceCode.getTokenBefore does not - * handle a comment as an argument correctly. - */ - const precedingTokens = sourceCode.ast.comments.reduce((commentMap, comment) => { - const tokenOrCommentBefore = sourceCode.getTokenBefore(comment, { includeComments: true }), - tokenBefore = commentMap.has(tokenOrCommentBefore) ? commentMap.get(tokenOrCommentBefore) : tokenOrCommentBefore; - - return commentMap.set(comment, tokenBefore); - }, new WeakMap()); - - sourceCode.lines.forEach((line, lineIndex) => { - const lineNumber = lineIndex + 1; - - if (!tokenInfo.firstTokensByLineNumber.has(lineNumber)) { - - // Don't check indentation on blank lines - return; - } - - const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(lineNumber); - - if (firstTokenOfLine.loc.start.line !== lineNumber) { - - // Don't check the indentation of multi-line tokens (e.g. template - // literals or block comments) twice. - return; - } - - if (astUtils.isCommentToken(firstTokenOfLine)) { - const tokenBefore = precedingTokens.get(firstTokenOfLine), - tokenAfter = tokenBefore ? sourceCode.getTokenAfter(tokenBefore) : sourceCode.ast.tokens[0], - mayAlignWithBefore = tokenBefore && !hasBlankLinesBetween(tokenBefore, firstTokenOfLine), - mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter), - validateTokenBefore = validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)), - validateTokenAfter = validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter)); - - /* - * If a comment precedes a line that begins with a semicolon token, - * align to that token, i.e. - * - * let foo - * // comment - * ;(async () => {})() - */ - if (tokenAfter && astUtils.isSemicolonToken(tokenAfter) && !astUtils.isTokenOnSameLine(firstTokenOfLine, tokenAfter)) { - offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0); - } - - // If a comment matches the expected indentation of the token - // immediately before or after, don't report it. - if (mayAlignWithBefore && validateTokenBefore || mayAlignWithAfter && validateTokenAfter) { - return; - } - } - - // If the token matches the expected indentation, don't report it. - if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) { - return; - } - - // Otherwise, report the token/comment. - report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine)); - }); - }, - } - ); - }, -}; diff --git a/tests/lib/rules/indent.test.js b/tests/lib/rules/indent.test.js deleted file mode 100644 index d1f885a..0000000 --- a/tests/lib/rules/indent.test.js +++ /dev/null @@ -1,316 +0,0 @@ -/** -* @fileoverview Check indentation at the beginning and end of a function call -*/ -'use strict'; - -// ------------------------------------------------------------------------------ -// Requirements -// ------------------------------------------------------------------------------ - -var rule = require('../../../lib/rules/indent'), - formatCode = require('../../code-helper'), - ruleTester = require('../../ruleTesters').es6(), - validExample, varOnlyExample, switchTest, constExample, flatTernaryValid, - invalidExample, invalidExample2, invalidExample3, constInvalid, - classInvalid; - -validExample = formatCode( - 'var a = 1,', - ' b = 2,', - ' c = 3;', - '', - 'function test() {', - ' a()', - ' .b(function() {', - ' var a = 1,', - ' b = 2;', - '', - ' return a()', - ' .b(function() {});', - ' });', - '}', - '', - 'function test2() {', - ' var arr = [ 1, 2, 3 ],', - ' noInit, andAgain;', - '', - ' // This comment should be indented with the if statement', - ' if (noInit) {', - ' var a = 1,', - ' b = 2;', - ' }', - '}', - '', - 'class MyClass {', - ' /**', - ' * This should be indented with the function.', - ' *', - ' * @param {number} num base number to add', - ' */', - ' constructor(num) {', - ' this.a = num;', - ' }', - '', - ' add(b) {', - ' return this.a + b;', - ' }', - '}', - '', - 'const myClass = new MyClass();', - '', - 'for (let i = 1; i < 10; i++) {', - ' console.log(i);', - '}', - '', - 'myFunc().then((var1) => {', - ' return doSomething(var1);', - '});', - '', - 'myFunc(', - ' myClass,', - ' a,', - ' b,', - ' c', - ');', - '', - 'try {', - ' myFunc();', - '} catch (err) {', - ' console.error(err);', - '}', - '', - '(function() {', - ' doSomethingNow();', - '})();' -); - -varOnlyExample = formatCode( - 'var a = 1,', - ' b = 2,', - ' c = 3;' -); - -flatTernaryValid = formatCode( - 'var a =', - ' foo > 0 ? bar :', - ' foo < 0 ? baz :', - ' qiz;' -); - -invalidExample = formatCode( - 'function test() {', - ' var a = 1,', - ' b = 2;', - '', - ' return a + b;', - '}', - '', - 'myFunc(', - 'myClass,', - 'a', - ');', - '', - 'var foo = {', - ' bar: 1,', - ' baz: 2,', - '};' -); - -invalidExample2 = formatCode( - 'var a = 1,', - ' b = 2;', - '', - 'function badIndent() {', - ' a = b;', - '}' -); - -invalidExample3 = formatCode( - 'function test() {', - 'notindented();', - '}' -); - -switchTest = formatCode( - 'switch (a) {', - ' case 1:', - ' break;', - ' default:', - ' c = a + b', - '}' -); - -constExample = formatCode( - 'const A = 1,', - ' B = 2;', - '', - 'const myArr = [', - ' {', - ' a: 1,', - ' b: 2,', - ' },', - '];' -); - -constInvalid = formatCode( - 'const A = 1,', - ' B = 2;', - '', - 'const C = 3,', - ' D = 4;' -); - -classInvalid = formatCode( - 'class MyClass {', - 'constructor(num) {', - ' this.a = num;', - '}', - '', - 'add(b) {', - ' return this.a + b;', - '}', - '}' -); - -// ------------------------------------------------------------------------------ -// Tests -// ------------------------------------------------------------------------------ - -ruleTester.run('indent', rule, { - valid: [ - { - code: validExample, - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - }, - { - code: switchTest, - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - }, - { - code: constExample, - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - parserOptions: { ecmaVersion: 6 }, - }, - { - code: varOnlyExample, - options: [ 3, { 'VariableDeclaratorOffset': 1 } ], - }, - { - code: flatTernaryValid, - options: [ 3, { 'flatTernaryExpressions': true } ], - }, - ], - - invalid: [ - { - code: invalidExample, - errors: [ - { - message: 'Expected indentation of 7 spaces but found 6.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 3 spaces but found 2.', - type: 'Identifier', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - }, - { - code: invalidExample2, - errors: [ - { - message: 'Expected indentation of 3 spaces but found 2.', - type: 'Identifier', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - }, - { - code: invalidExample3, - errors: [ - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Identifier', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - }, - { - code: switchTest, - errors: [ - { - message: 'Expected indentation of 0 spaces but found 3.', - type: 'Keyword', - }, - { - message: 'Expected indentation of 3 spaces but found 6.', - type: 'Keyword', - }, - { - message: 'Expected indentation of 0 spaces but found 3.', - type: 'Keyword', - }, - { - message: 'Expected indentation of 3 spaces but found 6.', - type: 'Identifier', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 } } ], - }, - { - code: constInvalid, - errors: [ - { - message: 'Expected indentation of 6 spaces but found 3.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 6 spaces but found 4.', - type: 'Identifier', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - parserOptions: { ecmaVersion: 6 }, - }, - { - code: classInvalid, - errors: [ - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 6 spaces but found 3.', - type: 'Keyword', - }, - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Punctuator', - }, - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Identifier', - }, - { - message: 'Expected indentation of 6 spaces but found 3.', - type: 'Keyword', - }, - { - message: 'Expected indentation of 3 spaces but found 0.', - type: 'Punctuator', - }, - ], - options: [ 3, { 'VariableDeclaratorOffset': { 'var': 1, 'let': 1, 'const': 3 }, 'SwitchCase': 1 } ], - parserOptions: { ecmaVersion: 6 }, - }, - ], -});