| /** | |
| * @fileoverview This option sets a specific tab width for your code | |
| * | |
| * This rule has been ported and modified from nodeca. | |
| * @author Vitaly Puzrin | |
| * @author Gyandeep Singh | |
| */ | |
| "use strict"; | |
| //------------------------------------------------------------------------------ | |
| // Requirements | |
| //------------------------------------------------------------------------------ | |
| const astUtils = require("./utils/ast-utils"); | |
| //------------------------------------------------------------------------------ | |
| // Rule Definition | |
| //------------------------------------------------------------------------------ | |
| /* istanbul ignore next: this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway. */ | |
| module.exports = { | |
| meta: { | |
| type: "layout", | |
| docs: { | |
| description: "enforce consistent indentation", | |
| category: "Stylistic Issues", | |
| recommended: false, | |
| url: "https://eslint.org/docs/rules/indent-legacy" | |
| }, | |
| deprecated: true, | |
| replacedBy: ["indent"], | |
| fixable: "whitespace", | |
| schema: [ | |
| { | |
| oneOf: [ | |
| { | |
| enum: ["tab"] | |
| }, | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| } | |
| ] | |
| }, | |
| { | |
| type: "object", | |
| properties: { | |
| SwitchCase: { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| VariableDeclarator: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| type: "object", | |
| properties: { | |
| var: { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| let: { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| const: { | |
| type: "integer", | |
| minimum: 0 | |
| } | |
| } | |
| } | |
| ] | |
| }, | |
| outerIIFEBody: { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| MemberExpression: { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| FunctionDeclaration: { | |
| type: "object", | |
| properties: { | |
| parameters: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| enum: ["first"] | |
| } | |
| ] | |
| }, | |
| body: { | |
| type: "integer", | |
| minimum: 0 | |
| } | |
| } | |
| }, | |
| FunctionExpression: { | |
| type: "object", | |
| properties: { | |
| parameters: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| enum: ["first"] | |
| } | |
| ] | |
| }, | |
| body: { | |
| type: "integer", | |
| minimum: 0 | |
| } | |
| } | |
| }, | |
| CallExpression: { | |
| type: "object", | |
| properties: { | |
| parameters: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| enum: ["first"] | |
| } | |
| ] | |
| } | |
| } | |
| }, | |
| ArrayExpression: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| enum: ["first"] | |
| } | |
| ] | |
| }, | |
| ObjectExpression: { | |
| oneOf: [ | |
| { | |
| type: "integer", | |
| minimum: 0 | |
| }, | |
| { | |
| enum: ["first"] | |
| } | |
| ] | |
| } | |
| }, | |
| additionalProperties: false | |
| } | |
| ], | |
| messages: { | |
| expected: "Expected indentation of {{expected}} but found {{actual}}." | |
| } | |
| }, | |
| create(context) { | |
| const DEFAULT_VARIABLE_INDENT = 1; | |
| const DEFAULT_PARAMETER_INDENT = null; // For backwards compatibility, don't check parameter indentation unless specified in the config | |
| const DEFAULT_FUNCTION_BODY_INDENT = 1; | |
| let indentType = "space"; | |
| let indentSize = 4; | |
| const options = { | |
| SwitchCase: 0, | |
| VariableDeclarator: { | |
| var: DEFAULT_VARIABLE_INDENT, | |
| let: DEFAULT_VARIABLE_INDENT, | |
| const: DEFAULT_VARIABLE_INDENT | |
| }, | |
| outerIIFEBody: null, | |
| 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 | |
| }, | |
| ArrayExpression: 1, | |
| ObjectExpression: 1 | |
| }; | |
| const sourceCode = context.getSourceCode(); | |
| if (context.options.length) { | |
| if (context.options[0] === "tab") { | |
| indentSize = 1; | |
| indentType = "tab"; | |
| } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === "number") { | |
| indentSize = context.options[0]; | |
| indentType = "space"; | |
| } | |
| if (context.options[1]) { | |
| const opts = context.options[1]; | |
| options.SwitchCase = opts.SwitchCase || 0; | |
| const variableDeclaratorRules = opts.VariableDeclarator; | |
| if (typeof variableDeclaratorRules === "number") { | |
| options.VariableDeclarator = { | |
| var: variableDeclaratorRules, | |
| let: variableDeclaratorRules, | |
| const: variableDeclaratorRules | |
| }; | |
| } else if (typeof variableDeclaratorRules === "object") { | |
| Object.assign(options.VariableDeclarator, variableDeclaratorRules); | |
| } | |
| if (typeof opts.outerIIFEBody === "number") { | |
| options.outerIIFEBody = opts.outerIIFEBody; | |
| } | |
| if (typeof opts.MemberExpression === "number") { | |
| options.MemberExpression = opts.MemberExpression; | |
| } | |
| if (typeof opts.FunctionDeclaration === "object") { | |
| Object.assign(options.FunctionDeclaration, opts.FunctionDeclaration); | |
| } | |
| if (typeof opts.FunctionExpression === "object") { | |
| Object.assign(options.FunctionExpression, opts.FunctionExpression); | |
| } | |
| if (typeof opts.CallExpression === "object") { | |
| Object.assign(options.CallExpression, opts.CallExpression); | |
| } | |
| if (typeof opts.ArrayExpression === "number" || typeof opts.ArrayExpression === "string") { | |
| options.ArrayExpression = opts.ArrayExpression; | |
| } | |
| if (typeof opts.ObjectExpression === "number" || typeof opts.ObjectExpression === "string") { | |
| options.ObjectExpression = opts.ObjectExpression; | |
| } | |
| } | |
| } | |
| const caseIndentStore = {}; | |
| /** | |
| * 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 && actualTabs > 0) { | |
| foundStatement = `${actualSpaces} ${foundSpacesWord} and ${actualTabs} ${foundTabsWord}`; // e.g. "1 space and 2 tabs" | |
| } else 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 {ASTNode} node Node violating the indent rule | |
| * @param {int} needed Expected indentation character count | |
| * @param {int} gottenSpaces Indentation space count in the actual node/code | |
| * @param {int} gottenTabs Indentation tab count in the actual node/code | |
| * @param {Object=} loc Error line and column location | |
| * @param {boolean} isLastNodeCheck Is the error for last node check | |
| * @returns {void} | |
| */ | |
| function report(node, needed, gottenSpaces, gottenTabs, loc, isLastNodeCheck) { | |
| if (gottenSpaces && gottenTabs) { | |
| // To avoid conflicts with `no-mixed-spaces-and-tabs`, don't report lines that have both spaces and tabs. | |
| return; | |
| } | |
| const desiredIndent = (indentType === "space" ? " " : "\t").repeat(needed); | |
| const textRange = isLastNodeCheck | |
| ? [node.range[1] - node.loc.end.column, node.range[1] - node.loc.end.column + gottenSpaces + gottenTabs] | |
| : [node.range[0] - node.loc.start.column, node.range[0] - node.loc.start.column + gottenSpaces + gottenTabs]; | |
| context.report({ | |
| node, | |
| loc, | |
| messageId: "expected", | |
| data: createErrorMessageData(needed, gottenSpaces, gottenTabs), | |
| fix: fixer => fixer.replaceTextRange(textRange, desiredIndent) | |
| }); | |
| } | |
| /** | |
| * Get the actual indent of node | |
| * @param {ASTNode|Token} node Node to examine | |
| * @param {boolean} [byLastLine=false] get indent of node's last line | |
| * @returns {Object} The node's indent. Contains keys `space` and `tab`, representing the indent of each character. Also | |
| * contains keys `goodChar` and `badChar`, where `goodChar` is the amount of the user's desired indentation character, and | |
| * `badChar` is the amount of the other indentation character. | |
| */ | |
| function getNodeIndent(node, byLastLine) { | |
| const token = byLastLine ? sourceCode.getLastToken(node) : sourceCode.getFirstToken(node); | |
| const srcCharsBeforeNode = sourceCode.getText(token, token.loc.start.column).split(""); | |
| const indentChars = srcCharsBeforeNode.slice(0, srcCharsBeforeNode.findIndex(char => char !== " " && char !== "\t")); | |
| const spaces = indentChars.filter(char => char === " ").length; | |
| const tabs = indentChars.filter(char => char === "\t").length; | |
| return { | |
| space: spaces, | |
| tab: tabs, | |
| goodChar: indentType === "space" ? spaces : tabs, | |
| badChar: indentType === "space" ? tabs : spaces | |
| }; | |
| } | |
| /** | |
| * Checks node is the first in its own start line. By default it looks by start line. | |
| * @param {ASTNode} node The node to check | |
| * @param {boolean} [byEndLocation=false] Lookup based on start position or end | |
| * @returns {boolean} true if its the first in the its start line | |
| */ | |
| function isNodeFirstInLine(node, byEndLocation) { | |
| const firstToken = byEndLocation === true ? sourceCode.getLastToken(node, 1) : sourceCode.getTokenBefore(node), | |
| startLine = byEndLocation === true ? node.loc.end.line : node.loc.start.line, | |
| endLine = firstToken ? firstToken.loc.end.line : -1; | |
| return startLine !== endLine; | |
| } | |
| /** | |
| * Check indent for node | |
| * @param {ASTNode} node Node to check | |
| * @param {int} neededIndent needed indent | |
| * @returns {void} | |
| */ | |
| function checkNodeIndent(node, neededIndent) { | |
| const actualIndent = getNodeIndent(node, false); | |
| if ( | |
| node.type !== "ArrayExpression" && | |
| node.type !== "ObjectExpression" && | |
| (actualIndent.goodChar !== neededIndent || actualIndent.badChar !== 0) && | |
| isNodeFirstInLine(node) | |
| ) { | |
| report(node, neededIndent, actualIndent.space, actualIndent.tab); | |
| } | |
| if (node.type === "IfStatement" && node.alternate) { | |
| const elseToken = sourceCode.getTokenBefore(node.alternate); | |
| checkNodeIndent(elseToken, neededIndent); | |
| if (!isNodeFirstInLine(node.alternate)) { | |
| checkNodeIndent(node.alternate, neededIndent); | |
| } | |
| } | |
| if (node.type === "TryStatement" && node.handler) { | |
| const catchToken = sourceCode.getFirstToken(node.handler); | |
| checkNodeIndent(catchToken, neededIndent); | |
| } | |
| if (node.type === "TryStatement" && node.finalizer) { | |
| const finallyToken = sourceCode.getTokenBefore(node.finalizer); | |
| checkNodeIndent(finallyToken, neededIndent); | |
| } | |
| if (node.type === "DoWhileStatement") { | |
| const whileToken = sourceCode.getTokenAfter(node.body); | |
| checkNodeIndent(whileToken, neededIndent); | |
| } | |
| } | |
| /** | |
| * Check indent for nodes list | |
| * @param {ASTNode[]} nodes list of node objects | |
| * @param {int} indent needed indent | |
| * @returns {void} | |
| */ | |
| function checkNodesIndent(nodes, indent) { | |
| nodes.forEach(node => checkNodeIndent(node, indent)); | |
| } | |
| /** | |
| * Check last node line indent this detects, that block closed correctly | |
| * @param {ASTNode} node Node to examine | |
| * @param {int} lastLineIndent needed indent | |
| * @returns {void} | |
| */ | |
| function checkLastNodeLineIndent(node, lastLineIndent) { | |
| const lastToken = sourceCode.getLastToken(node); | |
| const endIndent = getNodeIndent(lastToken, true); | |
| if ((endIndent.goodChar !== lastLineIndent || endIndent.badChar !== 0) && isNodeFirstInLine(node, true)) { | |
| report( | |
| node, | |
| lastLineIndent, | |
| endIndent.space, | |
| endIndent.tab, | |
| { line: lastToken.loc.start.line, column: lastToken.loc.start.column }, | |
| true | |
| ); | |
| } | |
| } | |
| /** | |
| * Check last node line indent this detects, that block closed correctly | |
| * This function for more complicated return statement case, where closing parenthesis may be followed by ';' | |
| * @param {ASTNode} node Node to examine | |
| * @param {int} firstLineIndent first line needed indent | |
| * @returns {void} | |
| */ | |
| function checkLastReturnStatementLineIndent(node, firstLineIndent) { | |
| /* | |
| * in case if return statement ends with ');' we have traverse back to ')' | |
| * otherwise we'll measure indent for ';' and replace ')' | |
| */ | |
| const lastToken = sourceCode.getLastToken(node, astUtils.isClosingParenToken); | |
| const textBeforeClosingParenthesis = sourceCode.getText(lastToken, lastToken.loc.start.column).slice(0, -1); | |
| if (textBeforeClosingParenthesis.trim()) { | |
| // There are tokens before the closing paren, don't report this case | |
| return; | |
| } | |
| const endIndent = getNodeIndent(lastToken, true); | |
| if (endIndent.goodChar !== firstLineIndent) { | |
| report( | |
| node, | |
| firstLineIndent, | |
| endIndent.space, | |
| endIndent.tab, | |
| { line: lastToken.loc.start.line, column: lastToken.loc.start.column }, | |
| true | |
| ); | |
| } | |
| } | |
| /** | |
| * Check first node line indent is correct | |
| * @param {ASTNode} node Node to examine | |
| * @param {int} firstLineIndent needed indent | |
| * @returns {void} | |
| */ | |
| function checkFirstNodeLineIndent(node, firstLineIndent) { | |
| const startIndent = getNodeIndent(node, false); | |
| if ((startIndent.goodChar !== firstLineIndent || startIndent.badChar !== 0) && isNodeFirstInLine(node)) { | |
| report( | |
| node, | |
| firstLineIndent, | |
| startIndent.space, | |
| startIndent.tab, | |
| { line: node.loc.start.line, column: node.loc.start.column } | |
| ); | |
| } | |
| } | |
| /** | |
| * Returns a parent node of given node based on a specified type | |
| * if not present then return null | |
| * @param {ASTNode} node node to examine | |
| * @param {string} type type that is being looked for | |
| * @param {string} stopAtList end points for the evaluating code | |
| * @returns {ASTNode|void} if found then node otherwise null | |
| */ | |
| function getParentNodeByType(node, type, stopAtList) { | |
| let parent = node.parent; | |
| const stopAtSet = new Set(stopAtList || ["Program"]); | |
| while (parent.type !== type && !stopAtSet.has(parent.type) && parent.type !== "Program") { | |
| parent = parent.parent; | |
| } | |
| return parent.type === type ? parent : null; | |
| } | |
| /** | |
| * Returns the VariableDeclarator based on the current node | |
| * if not present then return null | |
| * @param {ASTNode} node node to examine | |
| * @returns {ASTNode|void} if found then node otherwise null | |
| */ | |
| function getVariableDeclaratorNode(node) { | |
| return getParentNodeByType(node, "VariableDeclarator"); | |
| } | |
| /** | |
| * Check to see if the node is part of the multi-line variable declaration. | |
| * Also if its on the same line as the varNode | |
| * @param {ASTNode} node node to check | |
| * @param {ASTNode} varNode variable declaration node to check against | |
| * @returns {boolean} True if all the above condition satisfy | |
| */ | |
| function isNodeInVarOnTop(node, varNode) { | |
| return varNode && | |
| varNode.parent.loc.start.line === node.loc.start.line && | |
| varNode.parent.declarations.length > 1; | |
| } | |
| /** | |
| * Check to see if the argument before the callee node is multi-line and | |
| * there should only be 1 argument before the callee node | |
| * @param {ASTNode} node node to check | |
| * @returns {boolean} True if arguments are multi-line | |
| */ | |
| function isArgBeforeCalleeNodeMultiline(node) { | |
| const parent = node.parent; | |
| if (parent.arguments.length >= 2 && parent.arguments[1] === node) { | |
| return parent.arguments[0].loc.end.line > parent.arguments[0].loc.start.line; | |
| } | |
| return false; | |
| } | |
| /** | |
| * 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) { | |
| const parent = node.parent; | |
| let stmt = parent.parent; | |
| /* | |
| * Verify that the node is an IIEF | |
| */ | |
| if ( | |
| parent.type !== "CallExpression" || | |
| parent.callee !== node) { | |
| return false; | |
| } | |
| /* | |
| * Navigate legal ancestors to determine whether this IIEF is outer | |
| */ | |
| while ( | |
| stmt.type === "UnaryExpression" && ( | |
| stmt.operator === "!" || | |
| stmt.operator === "~" || | |
| stmt.operator === "+" || | |
| stmt.operator === "-") || | |
| stmt.type === "AssignmentExpression" || | |
| stmt.type === "LogicalExpression" || | |
| stmt.type === "SequenceExpression" || | |
| stmt.type === "VariableDeclarator") { | |
| stmt = stmt.parent; | |
| } | |
| return (( | |
| stmt.type === "ExpressionStatement" || | |
| stmt.type === "VariableDeclaration") && | |
| stmt.parent && stmt.parent.type === "Program" | |
| ); | |
| } | |
| /** | |
| * Check indent for function block content | |
| * @param {ASTNode} node A BlockStatement node that is inside of a function. | |
| * @returns {void} | |
| */ | |
| function checkIndentInFunctionBlock(node) { | |
| /* | |
| * Search first caller in chain. | |
| * Ex.: | |
| * | |
| * Models <- Identifier | |
| * .User | |
| * .find() | |
| * .exec(function() { | |
| * // function body | |
| * }); | |
| * | |
| * Looks for 'Models' | |
| */ | |
| const calleeNode = node.parent; // FunctionExpression | |
| let indent; | |
| if (calleeNode.parent && | |
| (calleeNode.parent.type === "Property" || | |
| calleeNode.parent.type === "ArrayExpression")) { | |
| // If function is part of array or object, comma can be put at left | |
| indent = getNodeIndent(calleeNode, false).goodChar; | |
| } else { | |
| // If function is standalone, simple calculate indent | |
| indent = getNodeIndent(calleeNode).goodChar; | |
| } | |
| if (calleeNode.parent.type === "CallExpression") { | |
| const calleeParent = calleeNode.parent; | |
| if (calleeNode.type !== "FunctionExpression" && calleeNode.type !== "ArrowFunctionExpression") { | |
| if (calleeParent && calleeParent.loc.start.line < node.loc.start.line) { | |
| indent = getNodeIndent(calleeParent).goodChar; | |
| } | |
| } else { | |
| if (isArgBeforeCalleeNodeMultiline(calleeNode) && | |
| calleeParent.callee.loc.start.line === calleeParent.callee.loc.end.line && | |
| !isNodeFirstInLine(calleeNode)) { | |
| indent = getNodeIndent(calleeParent).goodChar; | |
| } | |
| } | |
| } | |
| /* | |
| * function body indent should be indent + indent size, unless this | |
| * is a FunctionDeclaration, FunctionExpression, or outer IIFE and the corresponding options are enabled. | |
| */ | |
| let functionOffset = indentSize; | |
| if (options.outerIIFEBody !== null && isOuterIIFE(calleeNode)) { | |
| functionOffset = options.outerIIFEBody * indentSize; | |
| } else if (calleeNode.type === "FunctionExpression") { | |
| functionOffset = options.FunctionExpression.body * indentSize; | |
| } else if (calleeNode.type === "FunctionDeclaration") { | |
| functionOffset = options.FunctionDeclaration.body * indentSize; | |
| } | |
| indent += functionOffset; | |
| // check if the node is inside a variable | |
| const parentVarNode = getVariableDeclaratorNode(node); | |
| if (parentVarNode && isNodeInVarOnTop(node, parentVarNode)) { | |
| indent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind]; | |
| } | |
| if (node.body.length > 0) { | |
| checkNodesIndent(node.body, indent); | |
| } | |
| checkLastNodeLineIndent(node, indent - functionOffset); | |
| } | |
| /** | |
| * Checks if the given node starts and ends on the same line | |
| * @param {ASTNode} node The node to check | |
| * @returns {boolean} Whether or not the block starts and ends on the same line. | |
| */ | |
| function isSingleLineNode(node) { | |
| const lastToken = sourceCode.getLastToken(node), | |
| startLine = node.loc.start.line, | |
| endLine = lastToken.loc.end.line; | |
| return startLine === endLine; | |
| } | |
| /** | |
| * Check to see if the first element inside an array is an object and on the same line as the node | |
| * If the node is not an array then it will return false. | |
| * @param {ASTNode} node node to check | |
| * @returns {boolean} success/failure | |
| */ | |
| function isFirstArrayElementOnSameLine(node) { | |
| if (node.type === "ArrayExpression" && node.elements[0]) { | |
| return node.elements[0].loc.start.line === node.loc.start.line && node.elements[0].type === "ObjectExpression"; | |
| } | |
| return false; | |
| } | |
| /** | |
| * Check indent for array block content or object block content | |
| * @param {ASTNode} node node to examine | |
| * @returns {void} | |
| */ | |
| function checkIndentInArrayOrObjectBlock(node) { | |
| // Skip inline | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| let elements = (node.type === "ArrayExpression") ? node.elements : node.properties; | |
| // filter out empty elements example would be [ , 2] so remove first element as espree considers it as null | |
| elements = elements.filter(elem => elem !== null); | |
| let nodeIndent; | |
| let elementsIndent; | |
| const parentVarNode = getVariableDeclaratorNode(node); | |
| // TODO - come up with a better strategy in future | |
| if (isNodeFirstInLine(node)) { | |
| const parent = node.parent; | |
| nodeIndent = getNodeIndent(parent).goodChar; | |
| if (!parentVarNode || parentVarNode.loc.start.line !== node.loc.start.line) { | |
| if (parent.type !== "VariableDeclarator" || parentVarNode === parentVarNode.parent.declarations[0]) { | |
| if (parent.type === "VariableDeclarator" && parentVarNode.loc.start.line === parent.loc.start.line) { | |
| nodeIndent += (indentSize * options.VariableDeclarator[parentVarNode.parent.kind]); | |
| } else if (parent.type === "ObjectExpression" || parent.type === "ArrayExpression") { | |
| const parentElements = node.parent.type === "ObjectExpression" ? node.parent.properties : node.parent.elements; | |
| if (parentElements[0] && | |
| parentElements[0].loc.start.line === parent.loc.start.line && | |
| parentElements[0].loc.end.line !== parent.loc.start.line) { | |
| /* | |
| * If the first element of the array spans multiple lines, don't increase the expected indentation of the rest. | |
| * e.g. [{ | |
| * foo: 1 | |
| * }, | |
| * { | |
| * bar: 1 | |
| * }] | |
| * the second object is not indented. | |
| */ | |
| } else if (typeof options[parent.type] === "number") { | |
| nodeIndent += options[parent.type] * indentSize; | |
| } else { | |
| nodeIndent = parentElements[0].loc.start.column; | |
| } | |
| } else if (parent.type === "CallExpression" || parent.type === "NewExpression") { | |
| if (typeof options.CallExpression.arguments === "number") { | |
| nodeIndent += options.CallExpression.arguments * indentSize; | |
| } else if (options.CallExpression.arguments === "first") { | |
| if (parent.arguments.indexOf(node) !== -1) { | |
| nodeIndent = parent.arguments[0].loc.start.column; | |
| } | |
| } else { | |
| nodeIndent += indentSize; | |
| } | |
| } else if (parent.type === "LogicalExpression" || parent.type === "ArrowFunctionExpression") { | |
| nodeIndent += indentSize; | |
| } | |
| } | |
| } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && parent.type !== "MemberExpression" && parent.type !== "ExpressionStatement" && parent.type !== "AssignmentExpression" && parent.type !== "Property") { | |
| nodeIndent += indentSize; | |
| } | |
| checkFirstNodeLineIndent(node, nodeIndent); | |
| } else { | |
| nodeIndent = getNodeIndent(node).goodChar; | |
| } | |
| if (options[node.type] === "first") { | |
| elementsIndent = elements.length ? elements[0].loc.start.column : 0; // If there are no elements, elementsIndent doesn't matter. | |
| } else { | |
| elementsIndent = nodeIndent + indentSize * options[node.type]; | |
| } | |
| /* | |
| * Check if the node is a multiple variable declaration; if so, then | |
| * make sure indentation takes that into account. | |
| */ | |
| if (isNodeInVarOnTop(node, parentVarNode)) { | |
| elementsIndent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind]; | |
| } | |
| checkNodesIndent(elements, elementsIndent); | |
| if (elements.length > 0) { | |
| // Skip last block line check if last item in same line | |
| if (elements[elements.length - 1].loc.end.line === node.loc.end.line) { | |
| return; | |
| } | |
| } | |
| checkLastNodeLineIndent(node, nodeIndent + | |
| (isNodeInVarOnTop(node, parentVarNode) ? options.VariableDeclarator[parentVarNode.parent.kind] * indentSize : 0)); | |
| } | |
| /** | |
| * Check if the node or node body is a BlockStatement or not | |
| * @param {ASTNode} node node to test | |
| * @returns {boolean} True if it or its body is a block statement | |
| */ | |
| function isNodeBodyBlock(node) { | |
| return node.type === "BlockStatement" || node.type === "ClassBody" || (node.body && node.body.type === "BlockStatement") || | |
| (node.consequent && node.consequent.type === "BlockStatement"); | |
| } | |
| /** | |
| * Check indentation for blocks | |
| * @param {ASTNode} node node to check | |
| * @returns {void} | |
| */ | |
| function blockIndentationCheck(node) { | |
| // Skip inline blocks | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| if (node.parent && ( | |
| node.parent.type === "FunctionExpression" || | |
| node.parent.type === "FunctionDeclaration" || | |
| node.parent.type === "ArrowFunctionExpression") | |
| ) { | |
| checkIndentInFunctionBlock(node); | |
| return; | |
| } | |
| let indent; | |
| let nodesToCheck = []; | |
| /* | |
| * For this statements we should check indent from statement beginning, | |
| * not from the beginning of the block. | |
| */ | |
| const statementsWithProperties = [ | |
| "IfStatement", "WhileStatement", "ForStatement", "ForInStatement", "ForOfStatement", "DoWhileStatement", "ClassDeclaration", "TryStatement" | |
| ]; | |
| if (node.parent && statementsWithProperties.indexOf(node.parent.type) !== -1 && isNodeBodyBlock(node)) { | |
| indent = getNodeIndent(node.parent).goodChar; | |
| } else if (node.parent && node.parent.type === "CatchClause") { | |
| indent = getNodeIndent(node.parent.parent).goodChar; | |
| } else { | |
| indent = getNodeIndent(node).goodChar; | |
| } | |
| if (node.type === "IfStatement" && node.consequent.type !== "BlockStatement") { | |
| nodesToCheck = [node.consequent]; | |
| } else if (Array.isArray(node.body)) { | |
| nodesToCheck = node.body; | |
| } else { | |
| nodesToCheck = [node.body]; | |
| } | |
| if (nodesToCheck.length > 0) { | |
| checkNodesIndent(nodesToCheck, indent + indentSize); | |
| } | |
| if (node.type === "BlockStatement") { | |
| checkLastNodeLineIndent(node, indent); | |
| } | |
| } | |
| /** | |
| * Filter out the elements which are on the same line of each other or the node. | |
| * basically have only 1 elements from each line except the variable declaration line. | |
| * @param {ASTNode} node Variable declaration node | |
| * @returns {ASTNode[]} Filtered elements | |
| */ | |
| function filterOutSameLineVars(node) { | |
| return node.declarations.reduce((finalCollection, elem) => { | |
| const lastElem = finalCollection[finalCollection.length - 1]; | |
| if ((elem.loc.start.line !== node.loc.start.line && !lastElem) || | |
| (lastElem && lastElem.loc.start.line !== elem.loc.start.line)) { | |
| finalCollection.push(elem); | |
| } | |
| return finalCollection; | |
| }, []); | |
| } | |
| /** | |
| * Check indentation for variable declarations | |
| * @param {ASTNode} node node to examine | |
| * @returns {void} | |
| */ | |
| function checkIndentInVariableDeclarations(node) { | |
| const elements = filterOutSameLineVars(node); | |
| const nodeIndent = getNodeIndent(node).goodChar; | |
| const lastElement = elements[elements.length - 1]; | |
| const elementsIndent = nodeIndent + indentSize * options.VariableDeclarator[node.kind]; | |
| checkNodesIndent(elements, elementsIndent); | |
| // Only check the last line if there is any token after the last item | |
| if (sourceCode.getLastToken(node).loc.end.line <= lastElement.loc.end.line) { | |
| return; | |
| } | |
| const tokenBeforeLastElement = sourceCode.getTokenBefore(lastElement); | |
| if (tokenBeforeLastElement.value === ",") { | |
| // Special case for comma-first syntax where the semicolon is indented | |
| checkLastNodeLineIndent(node, getNodeIndent(tokenBeforeLastElement).goodChar); | |
| } else { | |
| checkLastNodeLineIndent(node, elementsIndent - indentSize); | |
| } | |
| } | |
| /** | |
| * 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 blockLessNodes(node) { | |
| if (node.body.type !== "BlockStatement") { | |
| blockIndentationCheck(node); | |
| } | |
| } | |
| /** | |
| * Returns the expected indentation for the case statement | |
| * @param {ASTNode} node node to examine | |
| * @param {int} [providedSwitchIndent] indent for switch statement | |
| * @returns {int} indent size | |
| */ | |
| function expectedCaseIndent(node, providedSwitchIndent) { | |
| const switchNode = (node.type === "SwitchStatement") ? node : node.parent; | |
| const switchIndent = typeof providedSwitchIndent === "undefined" | |
| ? getNodeIndent(switchNode).goodChar | |
| : providedSwitchIndent; | |
| let caseIndent; | |
| if (caseIndentStore[switchNode.loc.start.line]) { | |
| return caseIndentStore[switchNode.loc.start.line]; | |
| } | |
| if (switchNode.cases.length > 0 && options.SwitchCase === 0) { | |
| caseIndent = switchIndent; | |
| } else { | |
| caseIndent = switchIndent + (indentSize * options.SwitchCase); | |
| } | |
| caseIndentStore[switchNode.loc.start.line] = caseIndent; | |
| return caseIndent; | |
| } | |
| /** | |
| * Checks wether a return statement is wrapped in () | |
| * @param {ASTNode} node node to examine | |
| * @returns {boolean} the result | |
| */ | |
| function isWrappedInParenthesis(node) { | |
| const regex = /^return\s*?\(\s*?\);*?/u; | |
| const statementWithoutArgument = sourceCode.getText(node).replace( | |
| sourceCode.getText(node.argument), "" | |
| ); | |
| return regex.test(statementWithoutArgument); | |
| } | |
| return { | |
| Program(node) { | |
| if (node.body.length > 0) { | |
| // Root nodes should have no indent | |
| checkNodesIndent(node.body, getNodeIndent(node).goodChar); | |
| } | |
| }, | |
| ClassBody: blockIndentationCheck, | |
| BlockStatement: blockIndentationCheck, | |
| WhileStatement: blockLessNodes, | |
| ForStatement: blockLessNodes, | |
| ForInStatement: blockLessNodes, | |
| ForOfStatement: blockLessNodes, | |
| DoWhileStatement: blockLessNodes, | |
| IfStatement(node) { | |
| if (node.consequent.type !== "BlockStatement" && node.consequent.loc.start.line > node.loc.start.line) { | |
| blockIndentationCheck(node); | |
| } | |
| }, | |
| VariableDeclaration(node) { | |
| if (node.declarations[node.declarations.length - 1].loc.start.line > node.declarations[0].loc.start.line) { | |
| checkIndentInVariableDeclarations(node); | |
| } | |
| }, | |
| ObjectExpression(node) { | |
| checkIndentInArrayOrObjectBlock(node); | |
| }, | |
| ArrayExpression(node) { | |
| checkIndentInArrayOrObjectBlock(node); | |
| }, | |
| MemberExpression(node) { | |
| if (typeof options.MemberExpression === "undefined") { | |
| return; | |
| } | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| /* | |
| * The typical layout of variable declarations and assignments | |
| * alter the expectation of correct indentation. Skip them. | |
| * TODO: Add appropriate configuration options for variable | |
| * declarations and assignments. | |
| */ | |
| if (getParentNodeByType(node, "VariableDeclarator", ["FunctionExpression", "ArrowFunctionExpression"])) { | |
| return; | |
| } | |
| if (getParentNodeByType(node, "AssignmentExpression", ["FunctionExpression"])) { | |
| return; | |
| } | |
| const propertyIndent = getNodeIndent(node).goodChar + indentSize * options.MemberExpression; | |
| const checkNodes = [node.property]; | |
| const dot = sourceCode.getTokenBefore(node.property); | |
| if (dot.type === "Punctuator" && dot.value === ".") { | |
| checkNodes.push(dot); | |
| } | |
| checkNodesIndent(checkNodes, propertyIndent); | |
| }, | |
| SwitchStatement(node) { | |
| // Switch is not a 'BlockStatement' | |
| const switchIndent = getNodeIndent(node).goodChar; | |
| const caseIndent = expectedCaseIndent(node, switchIndent); | |
| checkNodesIndent(node.cases, caseIndent); | |
| checkLastNodeLineIndent(node, switchIndent); | |
| }, | |
| SwitchCase(node) { | |
| // Skip inline cases | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| const caseIndent = expectedCaseIndent(node); | |
| checkNodesIndent(node.consequent, caseIndent + indentSize); | |
| }, | |
| FunctionDeclaration(node) { | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| if (options.FunctionDeclaration.parameters === "first" && node.params.length) { | |
| checkNodesIndent(node.params.slice(1), node.params[0].loc.start.column); | |
| } else if (options.FunctionDeclaration.parameters !== null) { | |
| checkNodesIndent(node.params, getNodeIndent(node).goodChar + indentSize * options.FunctionDeclaration.parameters); | |
| } | |
| }, | |
| FunctionExpression(node) { | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| if (options.FunctionExpression.parameters === "first" && node.params.length) { | |
| checkNodesIndent(node.params.slice(1), node.params[0].loc.start.column); | |
| } else if (options.FunctionExpression.parameters !== null) { | |
| checkNodesIndent(node.params, getNodeIndent(node).goodChar + indentSize * options.FunctionExpression.parameters); | |
| } | |
| }, | |
| ReturnStatement(node) { | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| const firstLineIndent = getNodeIndent(node).goodChar; | |
| // in case if return statement is wrapped in parenthesis | |
| if (isWrappedInParenthesis(node)) { | |
| checkLastReturnStatementLineIndent(node, firstLineIndent); | |
| } else { | |
| checkNodeIndent(node, firstLineIndent); | |
| } | |
| }, | |
| CallExpression(node) { | |
| if (isSingleLineNode(node)) { | |
| return; | |
| } | |
| if (options.CallExpression.arguments === "first" && node.arguments.length) { | |
| checkNodesIndent(node.arguments.slice(1), node.arguments[0].loc.start.column); | |
| } else if (options.CallExpression.arguments !== null) { | |
| checkNodesIndent(node.arguments, getNodeIndent(node).goodChar + indentSize * options.CallExpression.arguments); | |
| } | |
| } | |
| }; | |
| } | |
| }; |