--- /dev/null
+/**
+ * @fileoverview Validates spacing before and after semicolon
+ * @author Mathias Schreck
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+ meta: {
+ type: "layout",
+
+ docs: {
+ description: "enforce consistent spacing before and after semicolons",
+ category: "Stylistic Issues",
+ recommended: false,
+ url: "https://eslint.org/docs/rules/semi-spacing"
+ },
+
+ fixable: "whitespace",
+
+ schema: [
+ {
+ type: "object",
+ properties: {
+ before: {
+ type: "boolean",
+ default: false
+ },
+ after: {
+ type: "boolean",
+ default: true
+ }
+ },
+ additionalProperties: false
+ }
+ ]
+ },
+
+ create(context) {
+
+ const config = context.options[0],
+ sourceCode = context.getSourceCode();
+ let requireSpaceBefore = false,
+ requireSpaceAfter = true;
+
+ if (typeof config === "object") {
+ requireSpaceBefore = config.before;
+ requireSpaceAfter = config.after;
+ }
+
+ /**
+ * Checks if a given token has leading whitespace.
+ * @param {Object} token The token to check.
+ * @returns {boolean} True if the given token has leading space, false if not.
+ */
+ function hasLeadingSpace(token) {
+ const tokenBefore = sourceCode.getTokenBefore(token);
+
+ return tokenBefore && astUtils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);
+ }
+
+ /**
+ * Checks if a given token has trailing whitespace.
+ * @param {Object} token The token to check.
+ * @returns {boolean} True if the given token has trailing space, false if not.
+ */
+ function hasTrailingSpace(token) {
+ const tokenAfter = sourceCode.getTokenAfter(token);
+
+ return tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);
+ }
+
+ /**
+ * Checks if the given token is the last token in its line.
+ * @param {Token} token The token to check.
+ * @returns {boolean} Whether or not the token is the last in its line.
+ */
+ function isLastTokenInCurrentLine(token) {
+ const tokenAfter = sourceCode.getTokenAfter(token);
+
+ return !(tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter));
+ }
+
+ /**
+ * Checks if the given token is the first token in its line
+ * @param {Token} token The token to check.
+ * @returns {boolean} Whether or not the token is the first in its line.
+ */
+ function isFirstTokenInCurrentLine(token) {
+ const tokenBefore = sourceCode.getTokenBefore(token);
+
+ return !(tokenBefore && astUtils.isTokenOnSameLine(token, tokenBefore));
+ }
+
+ /**
+ * Checks if the next token of a given token is a closing parenthesis.
+ * @param {Token} token The token to check.
+ * @returns {boolean} Whether or not the next token of a given token is a closing parenthesis.
+ */
+ function isBeforeClosingParen(token) {
+ const nextToken = sourceCode.getTokenAfter(token);
+
+ return (nextToken && astUtils.isClosingBraceToken(nextToken) || astUtils.isClosingParenToken(nextToken));
+ }
+
+ /**
+ * Reports if the given token has invalid spacing.
+ * @param {Token} token The semicolon token to check.
+ * @param {ASTNode} node The corresponding node of the token.
+ * @returns {void}
+ */
+ function checkSemicolonSpacing(token, node) {
+ if (astUtils.isSemicolonToken(token)) {
+ const location = token.loc.start;
+
+ if (hasLeadingSpace(token)) {
+ if (!requireSpaceBefore) {
+ context.report({
+ node,
+ loc: location,
+ message: "Unexpected whitespace before semicolon.",
+ fix(fixer) {
+ const tokenBefore = sourceCode.getTokenBefore(token);
+
+ return fixer.removeRange([tokenBefore.range[1], token.range[0]]);
+ }
+ });
+ }
+ } else {
+ if (requireSpaceBefore) {
+ context.report({
+ node,
+ loc: location,
+ message: "Missing whitespace before semicolon.",
+ fix(fixer) {
+ return fixer.insertTextBefore(token, " ");
+ }
+ });
+ }
+ }
+
+ if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
+ if (hasTrailingSpace(token)) {
+ if (!requireSpaceAfter) {
+ context.report({
+ node,
+ loc: location,
+ message: "Unexpected whitespace after semicolon.",
+ fix(fixer) {
+ const tokenAfter = sourceCode.getTokenAfter(token);
+
+ return fixer.removeRange([token.range[1], tokenAfter.range[0]]);
+ }
+ });
+ }
+ } else {
+ if (requireSpaceAfter) {
+ context.report({
+ node,
+ loc: location,
+ message: "Missing whitespace after semicolon.",
+ fix(fixer) {
+ return fixer.insertTextAfter(token, " ");
+ }
+ });
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Checks the spacing of the semicolon with the assumption that the last token is the semicolon.
+ * @param {ASTNode} node The node to check.
+ * @returns {void}
+ */
+ function checkNode(node) {
+ const token = sourceCode.getLastToken(node);
+
+ checkSemicolonSpacing(token, node);
+ }
+
+ return {
+ VariableDeclaration: checkNode,
+ ExpressionStatement: checkNode,
+ BreakStatement: checkNode,
+ ContinueStatement: checkNode,
+ DebuggerStatement: checkNode,
+ ReturnStatement: checkNode,
+ ThrowStatement: checkNode,
+ ImportDeclaration: checkNode,
+ ExportNamedDeclaration: checkNode,
+ ExportAllDeclaration: checkNode,
+ ExportDefaultDeclaration: checkNode,
+ ForStatement(node) {
+ if (node.init) {
+ checkSemicolonSpacing(sourceCode.getTokenAfter(node.init), node);
+ }
+
+ if (node.test) {
+ checkSemicolonSpacing(sourceCode.getTokenAfter(node.test), node);
+ }
+ }
+ };
+ }
+};
projects / dotfiles / .git / blobdiff