Server IP : 150.95.80.236 / Your IP : 18.117.165.82 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/eslint/lib/rules/ |
Upload File : |
/** * @fileoverview Rule to require or disallow yoda comparisons * @author Nicholas C. Zakas */ "use strict"; //-------------------------------------------------------------------------- // Requirements //-------------------------------------------------------------------------- const astUtils = require("./utils/ast-utils"); //-------------------------------------------------------------------------- // Helpers //-------------------------------------------------------------------------- /** * Determines whether an operator is a comparison operator. * @param {string} operator The operator to check. * @returns {boolean} Whether or not it is a comparison operator. */ function isComparisonOperator(operator) { return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator); } /** * Determines whether an operator is an equality operator. * @param {string} operator The operator to check. * @returns {boolean} Whether or not it is an equality operator. */ function isEqualityOperator(operator) { return /^(==|===)$/u.test(operator); } /** * Determines whether an operator is one used in a range test. * Allowed operators are `<` and `<=`. * @param {string} operator The operator to check. * @returns {boolean} Whether the operator is used in range tests. */ function isRangeTestOperator(operator) { return ["<", "<="].includes(operator); } /** * Determines whether a non-Literal node is a negative number that should be * treated as if it were a single Literal node. * @param {ASTNode} node Node to test. * @returns {boolean} True if the node is a negative number that looks like a * real literal and should be treated as such. */ function isNegativeNumericLiteral(node) { return ( node.type === "UnaryExpression" && node.operator === "-" && node.prefix && astUtils.isNumericLiteral(node.argument) ); } /** * Determines whether a non-Literal node should be treated as a single Literal node. * @param {ASTNode} node Node to test * @returns {boolean} True if the node should be treated as a single Literal node. */ function looksLikeLiteral(node) { return isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node); } /** * Attempts to derive a Literal node from nodes that are treated like literals. * @param {ASTNode} node Node to normalize. * @returns {ASTNode} One of the following options. * 1. The original node if the node is already a Literal * 2. A normalized Literal node with the negative number as the value if the * node represents a negative number literal. * 3. A normalized Literal node with the string as the value if the node is * a Template Literal without expression. * 4. Otherwise `null`. */ function getNormalizedLiteral(node) { if (node.type === "Literal") { return node; } if (isNegativeNumericLiteral(node)) { return { type: "Literal", value: -node.argument.value, raw: `-${node.argument.value}` }; } if (astUtils.isStaticTemplateLiteral(node)) { return { type: "Literal", value: node.quasis[0].value.cooked, raw: node.quasis[0].value.raw }; } return null; } //------------------------------------------------------------------------------ // Rule Definition //------------------------------------------------------------------------------ /** @type {import('../shared/types').Rule} */ module.exports = { meta: { type: "suggestion", docs: { description: 'Require or disallow "Yoda" conditions', recommended: false, url: "https://eslint.org/docs/latest/rules/yoda" }, schema: [ { enum: ["always", "never"] }, { type: "object", properties: { exceptRange: { type: "boolean", default: false }, onlyEquality: { type: "boolean", default: false } }, additionalProperties: false } ], fixable: "code", messages: { expected: "Expected literal to be on the {{expectedSide}} side of {{operator}}." } }, create(context) { // Default to "never" (!always) if no option const always = context.options[0] === "always"; const exceptRange = context.options[1] && context.options[1].exceptRange; const onlyEquality = context.options[1] && context.options[1].onlyEquality; const sourceCode = context.sourceCode; /** * Determines whether node represents a range test. * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside" * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and * both operators must be `<` or `<=`. Finally, the literal on the left side * must be less than or equal to the literal on the right side so that the * test makes any sense. * @param {ASTNode} node LogicalExpression node to test. * @returns {boolean} Whether node is a range test. */ function isRangeTest(node) { const left = node.left, right = node.right; /** * Determines whether node is of the form `0 <= x && x < 1`. * @returns {boolean} Whether node is a "between" range test. */ function isBetweenTest() { if (node.operator === "&&" && astUtils.isSameReference(left.right, right.left)) { const leftLiteral = getNormalizedLiteral(left.left); const rightLiteral = getNormalizedLiteral(right.right); if (leftLiteral === null && rightLiteral === null) { return false; } if (rightLiteral === null || leftLiteral === null) { return true; } if (leftLiteral.value <= rightLiteral.value) { return true; } } return false; } /** * Determines whether node is of the form `x < 0 || 1 <= x`. * @returns {boolean} Whether node is an "outside" range test. */ function isOutsideTest() { if (node.operator === "||" && astUtils.isSameReference(left.left, right.right)) { const leftLiteral = getNormalizedLiteral(left.right); const rightLiteral = getNormalizedLiteral(right.left); if (leftLiteral === null && rightLiteral === null) { return false; } if (rightLiteral === null || leftLiteral === null) { return true; } if (leftLiteral.value <= rightLiteral.value) { return true; } } return false; } /** * Determines whether node is wrapped in parentheses. * @returns {boolean} Whether node is preceded immediately by an open * paren token and followed immediately by a close * paren token. */ function isParenWrapped() { return astUtils.isParenthesised(sourceCode, node); } return ( node.type === "LogicalExpression" && left.type === "BinaryExpression" && right.type === "BinaryExpression" && isRangeTestOperator(left.operator) && isRangeTestOperator(right.operator) && (isBetweenTest() || isOutsideTest()) && isParenWrapped() ); } const OPERATOR_FLIP_MAP = { "===": "===", "!==": "!==", "==": "==", "!=": "!=", "<": ">", ">": "<", "<=": ">=", ">=": "<=" }; /** * Returns a string representation of a BinaryExpression node with its sides/operator flipped around. * @param {ASTNode} node The BinaryExpression node * @returns {string} A string representation of the node with the sides and operator flipped */ function getFlippedString(node) { const operatorToken = sourceCode.getFirstTokenBetween( node.left, node.right, token => token.value === node.operator ); const lastLeftToken = sourceCode.getTokenBefore(operatorToken); const firstRightToken = sourceCode.getTokenAfter(operatorToken); const source = sourceCode.getText(); const leftText = source.slice( node.range[0], lastLeftToken.range[1] ); const textBeforeOperator = source.slice( lastLeftToken.range[1], operatorToken.range[0] ); const textAfterOperator = source.slice( operatorToken.range[1], firstRightToken.range[0] ); const rightText = source.slice( firstRightToken.range[0], node.range[1] ); const tokenBefore = sourceCode.getTokenBefore(node); const tokenAfter = sourceCode.getTokenAfter(node); let prefix = ""; let suffix = ""; if ( tokenBefore && tokenBefore.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken) ) { prefix = " "; } if ( tokenAfter && node.range[1] === tokenAfter.range[0] && !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter) ) { suffix = " "; } return ( prefix + rightText + textBeforeOperator + OPERATOR_FLIP_MAP[operatorToken.value] + textAfterOperator + leftText + suffix ); } //-------------------------------------------------------------------------- // Public //-------------------------------------------------------------------------- return { BinaryExpression(node) { const expectedLiteral = always ? node.left : node.right; const expectedNonLiteral = always ? node.right : node.left; // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error. if ( (expectedNonLiteral.type === "Literal" || looksLikeLiteral(expectedNonLiteral)) && !( expectedLiteral.type === "Literal" || looksLikeLiteral(expectedLiteral) ) && !(!isEqualityOperator(node.operator) && onlyEquality) && isComparisonOperator(node.operator) && !(exceptRange && isRangeTest(node.parent)) ) { context.report({ node, messageId: "expected", data: { operator: node.operator, expectedSide: always ? "left" : "right" }, fix: fixer => fixer.replaceText(node, getFlippedString(node)) }); } } }; } };