+++ /dev/null
-/**
- * @fileoverview Rule to check empty newline after "var" statement
- * @author Gopal Venkatesan
- * @deprecated
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "layout",
-
- docs: {
- description: "require or disallow an empty line after variable declarations",
- category: "Stylistic Issues",
- recommended: false,
- url: "https://eslint.org/docs/rules/newline-after-var"
- },
- schema: [
- {
- enum: ["never", "always"]
- }
- ],
- fixable: "whitespace",
- messages: {
- expected: "Expected blank line after variable declarations.",
- unexpected: "Unexpected blank line after variable declarations."
- },
-
- deprecated: true,
-
- replacedBy: ["padding-line-between-statements"]
- },
-
- create(context) {
- const sourceCode = context.getSourceCode();
-
- // Default `mode` to "always".
- const mode = context.options[0] === "never" ? "never" : "always";
-
- // Cache starting and ending line numbers of comments for faster lookup
- const commentEndLine = sourceCode.getAllComments().reduce((result, token) => {
- result[token.loc.start.line] = token.loc.end.line;
- return result;
- }, {});
-
-
- //--------------------------------------------------------------------------
- // Helpers
- //--------------------------------------------------------------------------
-
- /**
- * Gets a token from the given node to compare line to the next statement.
- *
- * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.
- *
- * - The last token is semicolon.
- * - The semicolon is on a different line from the previous token of the semicolon.
- *
- * This behavior would address semicolon-less style code. e.g.:
- *
- * var foo = 1
- *
- * ;(a || b).doSomething()
- * @param {ASTNode} node The node to get.
- * @returns {Token} The token to compare line to the next statement.
- */
- function getLastToken(node) {
- const lastToken = sourceCode.getLastToken(node);
-
- if (lastToken.type === "Punctuator" && lastToken.value === ";") {
- const prevToken = sourceCode.getTokenBefore(lastToken);
-
- if (prevToken.loc.end.line !== lastToken.loc.start.line) {
- return prevToken;
- }
- }
-
- return lastToken;
- }
-
- /**
- * Determine if provided keyword is a variable declaration
- * @private
- * @param {string} keyword keyword to test
- * @returns {boolean} True if `keyword` is a type of var
- */
- function isVar(keyword) {
- return keyword === "var" || keyword === "let" || keyword === "const";
- }
-
- /**
- * Determine if provided keyword is a variant of for specifiers
- * @private
- * @param {string} keyword keyword to test
- * @returns {boolean} True if `keyword` is a variant of for specifier
- */
- function isForTypeSpecifier(keyword) {
- return keyword === "ForStatement" || keyword === "ForInStatement" || keyword === "ForOfStatement";
- }
-
- /**
- * Determine if provided keyword is an export specifiers
- * @private
- * @param {string} nodeType nodeType to test
- * @returns {boolean} True if `nodeType` is an export specifier
- */
- function isExportSpecifier(nodeType) {
- return nodeType === "ExportNamedDeclaration" || nodeType === "ExportSpecifier" ||
- nodeType === "ExportDefaultDeclaration" || nodeType === "ExportAllDeclaration";
- }
-
- /**
- * Determine if provided node is the last of their parent block.
- * @private
- * @param {ASTNode} node node to test
- * @returns {boolean} True if `node` is last of their parent block.
- */
- function isLastNode(node) {
- const token = sourceCode.getTokenAfter(node);
-
- return !token || (token.type === "Punctuator" && token.value === "}");
- }
-
- /**
- * Gets the last line of a group of consecutive comments
- * @param {number} commentStartLine The starting line of the group
- * @returns {number} The number of the last comment line of the group
- */
- function getLastCommentLineOfBlock(commentStartLine) {
- const currentCommentEnd = commentEndLine[commentStartLine];
-
- return commentEndLine[currentCommentEnd + 1] ? getLastCommentLineOfBlock(currentCommentEnd + 1) : currentCommentEnd;
- }
-
- /**
- * Determine if a token starts more than one line after a comment ends
- * @param {token} token The token being checked
- * @param {integer} commentStartLine The line number on which the comment starts
- * @returns {boolean} True if `token` does not start immediately after a comment
- */
- function hasBlankLineAfterComment(token, commentStartLine) {
- return token.loc.start.line > getLastCommentLineOfBlock(commentStartLine) + 1;
- }
-
- /**
- * Checks that a blank line exists after a variable declaration when mode is
- * set to "always", or checks that there is no blank line when mode is set
- * to "never"
- * @private
- * @param {ASTNode} node `VariableDeclaration` node to test
- * @returns {void}
- */
- function checkForBlankLine(node) {
-
- /*
- * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will
- * sometimes be second-last if there is a semicolon on a different line.
- */
- const lastToken = getLastToken(node),
-
- /*
- * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken
- * is the last token of the node.
- */
- nextToken = lastToken === sourceCode.getLastToken(node) ? sourceCode.getTokenAfter(node) : sourceCode.getLastToken(node),
- nextLineNum = lastToken.loc.end.line + 1;
-
- // Ignore if there is no following statement
- if (!nextToken) {
- return;
- }
-
- // Ignore if parent of node is a for variant
- if (isForTypeSpecifier(node.parent.type)) {
- return;
- }
-
- // Ignore if parent of node is an export specifier
- if (isExportSpecifier(node.parent.type)) {
- return;
- }
-
- /*
- * Some coding styles use multiple `var` statements, so do nothing if
- * the next token is a `var` statement.
- */
- if (nextToken.type === "Keyword" && isVar(nextToken.value)) {
- return;
- }
-
- // Ignore if it is last statement in a block
- if (isLastNode(node)) {
- return;
- }
-
- // Next statement is not a `var`...
- const noNextLineToken = nextToken.loc.start.line > nextLineNum;
- const hasNextLineComment = (typeof commentEndLine[nextLineNum] !== "undefined");
-
- if (mode === "never" && noNextLineToken && !hasNextLineComment) {
- context.report({
- node,
- messageId: "unexpected",
- data: { identifier: node.name },
- fix(fixer) {
- const linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(astUtils.LINEBREAK_MATCHER);
-
- return fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], `${linesBetween.slice(0, -1).join("")}\n${linesBetween[linesBetween.length - 1]}`);
- }
- });
- }
-
- // Token on the next line, or comment without blank line
- if (
- mode === "always" && (
- !noNextLineToken ||
- hasNextLineComment && !hasBlankLineAfterComment(nextToken, nextLineNum)
- )
- ) {
- context.report({
- node,
- messageId: "expected",
- data: { identifier: node.name },
- fix(fixer) {
- if ((noNextLineToken ? getLastCommentLineOfBlock(nextLineNum) : lastToken.loc.end.line) === nextToken.loc.start.line) {
- return fixer.insertTextBefore(nextToken, "\n\n");
- }
-
- return fixer.insertTextBeforeRange([nextToken.range[0] - nextToken.loc.start.column, nextToken.range[1]], "\n");
- }
- });
- }
- }
-
- //--------------------------------------------------------------------------
- // Public
- //--------------------------------------------------------------------------
-
- return {
- VariableDeclaration: checkForBlankLine
- };
-
- }
-};
projects / dotfiles / .git / blobdiff