+++ /dev/null
-/**
- * @fileoverview Rule to require braces in arrow function body.
- * @author Alberto RodrÃguez
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "suggestion",
-
- docs: {
- description: "require braces around arrow function bodies",
- category: "ECMAScript 6",
- recommended: false,
- url: "https://eslint.org/docs/rules/arrow-body-style"
- },
-
- schema: {
- anyOf: [
- {
- type: "array",
- items: [
- {
- enum: ["always", "never"]
- }
- ],
- minItems: 0,
- maxItems: 1
- },
- {
- type: "array",
- items: [
- {
- enum: ["as-needed"]
- },
- {
- type: "object",
- properties: {
- requireReturnForObjectLiteral: { type: "boolean" }
- },
- additionalProperties: false
- }
- ],
- minItems: 0,
- maxItems: 2
- }
- ]
- },
-
- fixable: "code",
-
- messages: {
- unexpectedOtherBlock: "Unexpected block statement surrounding arrow body.",
- unexpectedEmptyBlock: "Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.",
- unexpectedObjectBlock: "Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.",
- unexpectedSingleBlock: "Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.",
- expectedBlock: "Expected block statement surrounding arrow body."
- }
- },
-
- create(context) {
- const options = context.options;
- const always = options[0] === "always";
- const asNeeded = !options[0] || options[0] === "as-needed";
- const never = options[0] === "never";
- const requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;
- const sourceCode = context.getSourceCode();
-
- /**
- * Checks whether the given node has ASI problem or not.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.
- */
- function hasASIProblem(token) {
- return token && token.type === "Punctuator" && /^[([/`+-]/u.test(token.value);
- }
-
- /**
- * Gets the closing parenthesis which is the pair of the given opening parenthesis.
- * @param {Token} token The opening parenthesis token to get.
- * @returns {Token} The found closing parenthesis token.
- */
- function findClosingParen(token) {
- let node = sourceCode.getNodeByRangeIndex(token.range[1]);
-
- while (!astUtils.isParenthesised(sourceCode, node)) {
- node = node.parent;
- }
- return sourceCode.getTokenAfter(node);
- }
-
- /**
- * Determines whether a arrow function body needs braces
- * @param {ASTNode} node The arrow function node.
- * @returns {void}
- */
- function validate(node) {
- const arrowBody = node.body;
-
- if (arrowBody.type === "BlockStatement") {
- const blockBody = arrowBody.body;
-
- if (blockBody.length !== 1 && !never) {
- return;
- }
-
- if (asNeeded && requireReturnForObjectLiteral && blockBody[0].type === "ReturnStatement" &&
- blockBody[0].argument && blockBody[0].argument.type === "ObjectExpression") {
- return;
- }
-
- if (never || asNeeded && blockBody[0].type === "ReturnStatement") {
- let messageId;
-
- if (blockBody.length === 0) {
- messageId = "unexpectedEmptyBlock";
- } else if (blockBody.length > 1) {
- messageId = "unexpectedOtherBlock";
- } else if (blockBody[0].argument === null) {
- messageId = "unexpectedSingleBlock";
- } else if (astUtils.isOpeningBraceToken(sourceCode.getFirstToken(blockBody[0], { skip: 1 }))) {
- messageId = "unexpectedObjectBlock";
- } else {
- messageId = "unexpectedSingleBlock";
- }
-
- context.report({
- node,
- loc: arrowBody.loc.start,
- messageId,
- fix(fixer) {
- const fixes = [];
-
- if (blockBody.length !== 1 ||
- blockBody[0].type !== "ReturnStatement" ||
- !blockBody[0].argument ||
- hasASIProblem(sourceCode.getTokenAfter(arrowBody))
- ) {
- return fixes;
- }
-
- const openingBrace = sourceCode.getFirstToken(arrowBody);
- const closingBrace = sourceCode.getLastToken(arrowBody);
- const firstValueToken = sourceCode.getFirstToken(blockBody[0], 1);
- const lastValueToken = sourceCode.getLastToken(blockBody[0]);
- const commentsExist =
- sourceCode.commentsExistBetween(openingBrace, firstValueToken) ||
- sourceCode.commentsExistBetween(lastValueToken, closingBrace);
-
- /*
- * Remove tokens around the return value.
- * If comments don't exist, remove extra spaces as well.
- */
- if (commentsExist) {
- fixes.push(
- fixer.remove(openingBrace),
- fixer.remove(closingBrace),
- fixer.remove(sourceCode.getTokenAfter(openingBrace)) // return keyword
- );
- } else {
- fixes.push(
- fixer.removeRange([openingBrace.range[0], firstValueToken.range[0]]),
- fixer.removeRange([lastValueToken.range[1], closingBrace.range[1]])
- );
- }
-
- /*
- * If the first token of the reutrn value is `{` or the return value is a sequence expression,
- * enclose the return value by parentheses to avoid syntax error.
- */
- if (astUtils.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === "SequenceExpression") {
- fixes.push(
- fixer.insertTextBefore(firstValueToken, "("),
- fixer.insertTextAfter(lastValueToken, ")")
- );
- }
-
- /*
- * If the last token of the return statement is semicolon, remove it.
- * Non-block arrow body is an expression, not a statement.
- */
- if (astUtils.isSemicolonToken(lastValueToken)) {
- fixes.push(fixer.remove(lastValueToken));
- }
-
- return fixes;
- }
- });
- }
- } else {
- if (always || (asNeeded && requireReturnForObjectLiteral && arrowBody.type === "ObjectExpression")) {
- context.report({
- node,
- loc: arrowBody.loc.start,
- messageId: "expectedBlock",
- fix(fixer) {
- const fixes = [];
- const arrowToken = sourceCode.getTokenBefore(arrowBody, astUtils.isArrowToken);
- const firstBodyToken = sourceCode.getTokenAfter(arrowToken);
- const lastBodyToken = sourceCode.getLastToken(node);
- const isParenthesisedObjectLiteral =
- astUtils.isOpeningParenToken(firstBodyToken) &&
- astUtils.isOpeningBraceToken(sourceCode.getTokenAfter(firstBodyToken));
-
- // Wrap the value by a block and a return statement.
- fixes.push(
- fixer.insertTextBefore(firstBodyToken, "{return "),
- fixer.insertTextAfter(lastBodyToken, "}")
- );
-
- // If the value is object literal, remove parentheses which were forced by syntax.
- if (isParenthesisedObjectLiteral) {
- fixes.push(
- fixer.remove(firstBodyToken),
- fixer.remove(findClosingParen(firstBodyToken))
- );
- }
-
- return fixes;
- }
- });
- }
- }
- }
-
- return {
- "ArrowFunctionExpression:exit": validate
- };
- }
-};
projects / dotfiles / .git / blobdiff