+++ /dev/null
-/**
- * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
- * @author Benoît Zugmeyer
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "layout",
-
- docs: {
- description: "enforce consistent linebreak style for operators",
- category: "Stylistic Issues",
- recommended: false,
- url: "https://eslint.org/docs/rules/operator-linebreak"
- },
-
- schema: [
- {
- enum: ["after", "before", "none", null]
- },
- {
- type: "object",
- properties: {
- overrides: {
- type: "object",
- properties: {
- anyOf: {
- type: "string",
- enum: ["after", "before", "none", "ignore"]
- }
- }
- }
- },
- additionalProperties: false
- }
- ],
-
- fixable: "code"
- },
-
- create(context) {
-
- const usedDefaultGlobal = !context.options[0];
- const globalStyle = context.options[0] || "after";
- const options = context.options[1] || {};
- const styleOverrides = options.overrides ? Object.assign({}, options.overrides) : {};
-
- if (usedDefaultGlobal && !styleOverrides["?"]) {
- styleOverrides["?"] = "before";
- }
-
- if (usedDefaultGlobal && !styleOverrides[":"]) {
- styleOverrides[":"] = "before";
- }
-
- const sourceCode = context.getSourceCode();
-
- //--------------------------------------------------------------------------
- // Helpers
- //--------------------------------------------------------------------------
-
- /**
- * Gets a fixer function to fix rule issues
- * @param {Token} operatorToken The operator token of an expression
- * @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'
- * @returns {Function} A fixer function
- */
- function getFixer(operatorToken, desiredStyle) {
- return fixer => {
- const tokenBefore = sourceCode.getTokenBefore(operatorToken);
- const tokenAfter = sourceCode.getTokenAfter(operatorToken);
- const textBefore = sourceCode.text.slice(tokenBefore.range[1], operatorToken.range[0]);
- const textAfter = sourceCode.text.slice(operatorToken.range[1], tokenAfter.range[0]);
- const hasLinebreakBefore = !astUtils.isTokenOnSameLine(tokenBefore, operatorToken);
- const hasLinebreakAfter = !astUtils.isTokenOnSameLine(operatorToken, tokenAfter);
- let newTextBefore, newTextAfter;
-
- if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
-
- // If there is a comment before and after the operator, don't do a fix.
- if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore &&
- sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
-
- return null;
- }
-
- /*
- * If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator.
- * foo &&
- * bar
- * would get fixed to
- * foo
- * && bar
- */
- newTextBefore = textAfter;
- newTextAfter = textBefore;
- } else {
- const LINEBREAK_REGEX = astUtils.createGlobalLinebreakMatcher();
-
- // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
- newTextBefore = desiredStyle === "before" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, "");
- newTextAfter = desiredStyle === "after" || textAfter.trim() ? textAfter : textAfter.replace(LINEBREAK_REGEX, "");
-
- // If there was no change (due to interfering comments), don't output a fix.
- if (newTextBefore === textBefore && newTextAfter === textAfter) {
- return null;
- }
- }
-
- if (newTextAfter === "" && tokenAfter.type === "Punctuator" && "+-".includes(operatorToken.value) && tokenAfter.value === operatorToken.value) {
-
- // To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-.
- newTextAfter += " ";
- }
-
- return fixer.replaceTextRange([tokenBefore.range[1], tokenAfter.range[0]], newTextBefore + operatorToken.value + newTextAfter);
- };
- }
-
- /**
- * Checks the operator placement
- * @param {ASTNode} node The node to check
- * @param {ASTNode} leftSide The node that comes before the operator in `node`
- * @private
- * @returns {void}
- */
- function validateNode(node, leftSide) {
-
- /*
- * When the left part of a binary expression is a single expression wrapped in
- * parentheses (ex: `(a) + b`), leftToken will be the last token of the expression
- * and operatorToken will be the closing parenthesis.
- * The leftToken should be the last closing parenthesis, and the operatorToken
- * should be the token right after that.
- */
- const operatorToken = sourceCode.getTokenAfter(leftSide, astUtils.isNotClosingParenToken);
- const leftToken = sourceCode.getTokenBefore(operatorToken);
- const rightToken = sourceCode.getTokenAfter(operatorToken);
- const operator = operatorToken.value;
- const operatorStyleOverride = styleOverrides[operator];
- const style = operatorStyleOverride || globalStyle;
- const fix = getFixer(operatorToken, style);
-
- // if single line
- if (astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
- astUtils.isTokenOnSameLine(operatorToken, rightToken)) {
-
- // do nothing.
-
- } else if (operatorStyleOverride !== "ignore" && !astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
- !astUtils.isTokenOnSameLine(operatorToken, rightToken)) {
-
- // lone operator
- context.report({
- node,
- loc: {
- line: operatorToken.loc.end.line,
- column: operatorToken.loc.end.column
- },
- message: "Bad line breaking before and after '{{operator}}'.",
- data: {
- operator
- },
- fix
- });
-
- } else if (style === "before" && astUtils.isTokenOnSameLine(leftToken, operatorToken)) {
-
- context.report({
- node,
- loc: {
- line: operatorToken.loc.end.line,
- column: operatorToken.loc.end.column
- },
- message: "'{{operator}}' should be placed at the beginning of the line.",
- data: {
- operator
- },
- fix
- });
-
- } else if (style === "after" && astUtils.isTokenOnSameLine(operatorToken, rightToken)) {
-
- context.report({
- node,
- loc: {
- line: operatorToken.loc.end.line,
- column: operatorToken.loc.end.column
- },
- message: "'{{operator}}' should be placed at the end of the line.",
- data: {
- operator
- },
- fix
- });
-
- } else if (style === "none") {
-
- context.report({
- node,
- loc: {
- line: operatorToken.loc.end.line,
- column: operatorToken.loc.end.column
- },
- message: "There should be no line break before or after '{{operator}}'.",
- data: {
- operator
- },
- fix
- });
-
- }
- }
-
- /**
- * Validates a binary expression using `validateNode`
- * @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated
- * @returns {void}
- */
- function validateBinaryExpression(node) {
- validateNode(node, node.left);
- }
-
- //--------------------------------------------------------------------------
- // Public
- //--------------------------------------------------------------------------
-
- return {
- BinaryExpression: validateBinaryExpression,
- LogicalExpression: validateBinaryExpression,
- AssignmentExpression: validateBinaryExpression,
- VariableDeclarator(node) {
- if (node.init) {
- validateNode(node, node.id);
- }
- },
- ConditionalExpression(node) {
- validateNode(node, node.test);
- validateNode(node, node.consequent);
- }
- };
- }
-};
projects / dotfiles / .git / blobdiff