253 lines
9.9 KiB
JavaScript
253 lines
9.9 KiB
JavaScript
/**
|
|
* @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned.
|
|
* @author Annie Zhang, Pavel Strashkin
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Requirements
|
|
//--------------------------------------------------------------------------
|
|
|
|
const astUtils = require("./utils/ast-utils");
|
|
const esutils = require("esutils");
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Helpers
|
|
//--------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Determines if a pattern is `module.exports` or `module["exports"]`
|
|
* @param {ASTNode} pattern The left side of the AssignmentExpression
|
|
* @returns {boolean} True if the pattern is `module.exports` or `module["exports"]`
|
|
*/
|
|
function isModuleExports(pattern) {
|
|
if (pattern.type === "MemberExpression" && pattern.object.type === "Identifier" && pattern.object.name === "module") {
|
|
|
|
// module.exports
|
|
if (pattern.property.type === "Identifier" && pattern.property.name === "exports") {
|
|
return true;
|
|
}
|
|
|
|
// module["exports"]
|
|
if (pattern.property.type === "Literal" && pattern.property.value === "exports") {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determines if a string name is a valid identifier
|
|
* @param {string} name The string to be checked
|
|
* @param {int} ecmaVersion The ECMAScript version if specified in the parserOptions config
|
|
* @returns {boolean} True if the string is a valid identifier
|
|
*/
|
|
function isIdentifier(name, ecmaVersion) {
|
|
if (ecmaVersion >= 6) {
|
|
return esutils.keyword.isIdentifierES6(name);
|
|
}
|
|
return esutils.keyword.isIdentifierES5(name);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
const alwaysOrNever = { enum: ["always", "never"] };
|
|
const optionsObject = {
|
|
type: "object",
|
|
properties: {
|
|
considerPropertyDescriptor: {
|
|
type: "boolean"
|
|
},
|
|
includeCommonJSModuleExports: {
|
|
type: "boolean"
|
|
}
|
|
},
|
|
additionalProperties: false
|
|
};
|
|
|
|
module.exports = {
|
|
meta: {
|
|
type: "suggestion",
|
|
|
|
docs: {
|
|
description: "require function names to match the name of the variable or property to which they are assigned",
|
|
category: "Stylistic Issues",
|
|
recommended: false,
|
|
url: "https://eslint.org/docs/rules/func-name-matching"
|
|
},
|
|
|
|
schema: {
|
|
anyOf: [{
|
|
type: "array",
|
|
additionalItems: false,
|
|
items: [alwaysOrNever, optionsObject]
|
|
}, {
|
|
type: "array",
|
|
additionalItems: false,
|
|
items: [optionsObject]
|
|
}]
|
|
},
|
|
|
|
messages: {
|
|
matchProperty: "Function name `{{funcName}}` should match property name `{{name}}`.",
|
|
matchVariable: "Function name `{{funcName}}` should match variable name `{{name}}`.",
|
|
notMatchProperty: "Function name `{{funcName}}` should not match property name `{{name}}`.",
|
|
notMatchVariable: "Function name `{{funcName}}` should not match variable name `{{name}}`."
|
|
}
|
|
},
|
|
|
|
create(context) {
|
|
const options = (typeof context.options[0] === "object" ? context.options[0] : context.options[1]) || {};
|
|
const nameMatches = typeof context.options[0] === "string" ? context.options[0] : "always";
|
|
const considerPropertyDescriptor = options.considerPropertyDescriptor;
|
|
const includeModuleExports = options.includeCommonJSModuleExports;
|
|
const ecmaVersion = context.parserOptions && context.parserOptions.ecmaVersion ? context.parserOptions.ecmaVersion : 5;
|
|
|
|
/**
|
|
* Check whether node is a certain CallExpression.
|
|
* @param {string} objName object name
|
|
* @param {string} funcName function name
|
|
* @param {ASTNode} node The node to check
|
|
* @returns {boolean} `true` if node matches CallExpression
|
|
*/
|
|
function isPropertyCall(objName, funcName, node) {
|
|
if (!node) {
|
|
return false;
|
|
}
|
|
return node.type === "CallExpression" &&
|
|
node.callee.type === "MemberExpression" &&
|
|
node.callee.object.name === objName &&
|
|
node.callee.property.name === funcName;
|
|
}
|
|
|
|
/**
|
|
* Compares identifiers based on the nameMatches option
|
|
* @param {string} x the first identifier
|
|
* @param {string} y the second identifier
|
|
* @returns {boolean} whether the two identifiers should warn.
|
|
*/
|
|
function shouldWarn(x, y) {
|
|
return (nameMatches === "always" && x !== y) || (nameMatches === "never" && x === y);
|
|
}
|
|
|
|
/**
|
|
* Reports
|
|
* @param {ASTNode} node The node to report
|
|
* @param {string} name The variable or property name
|
|
* @param {string} funcName The function name
|
|
* @param {boolean} isProp True if the reported node is a property assignment
|
|
* @returns {void}
|
|
*/
|
|
function report(node, name, funcName, isProp) {
|
|
let messageId;
|
|
|
|
if (nameMatches === "always" && isProp) {
|
|
messageId = "matchProperty";
|
|
} else if (nameMatches === "always") {
|
|
messageId = "matchVariable";
|
|
} else if (isProp) {
|
|
messageId = "notMatchProperty";
|
|
} else {
|
|
messageId = "notMatchVariable";
|
|
}
|
|
context.report({
|
|
node,
|
|
messageId,
|
|
data: {
|
|
name,
|
|
funcName
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Determines whether a given node is a string literal
|
|
* @param {ASTNode} node The node to check
|
|
* @returns {boolean} `true` if the node is a string literal
|
|
*/
|
|
function isStringLiteral(node) {
|
|
return node.type === "Literal" && typeof node.value === "string";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Public
|
|
//--------------------------------------------------------------------------
|
|
|
|
return {
|
|
VariableDeclarator(node) {
|
|
if (!node.init || node.init.type !== "FunctionExpression" || node.id.type !== "Identifier") {
|
|
return;
|
|
}
|
|
if (node.init.id && shouldWarn(node.id.name, node.init.id.name)) {
|
|
report(node, node.id.name, node.init.id.name, false);
|
|
}
|
|
},
|
|
|
|
AssignmentExpression(node) {
|
|
if (
|
|
node.right.type !== "FunctionExpression" ||
|
|
(node.left.computed && node.left.property.type !== "Literal") ||
|
|
(!includeModuleExports && isModuleExports(node.left)) ||
|
|
(node.left.type !== "Identifier" && node.left.type !== "MemberExpression")
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const isProp = node.left.type === "MemberExpression";
|
|
const name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
|
|
|
|
if (node.right.id && isIdentifier(name) && shouldWarn(name, node.right.id.name)) {
|
|
report(node, name, node.right.id.name, isProp);
|
|
}
|
|
},
|
|
|
|
Property(node) {
|
|
if (node.value.type !== "FunctionExpression" || !node.value.id || node.computed && !isStringLiteral(node.key)) {
|
|
return;
|
|
}
|
|
|
|
if (node.key.type === "Identifier") {
|
|
const functionName = node.value.id.name;
|
|
let propertyName = node.key.name;
|
|
|
|
if (considerPropertyDescriptor && propertyName === "value") {
|
|
if (isPropertyCall("Object", "defineProperty", node.parent.parent) || isPropertyCall("Reflect", "defineProperty", node.parent.parent)) {
|
|
const property = node.parent.parent.arguments[1];
|
|
|
|
if (isStringLiteral(property) && shouldWarn(property.value, functionName)) {
|
|
report(node, property.value, functionName, true);
|
|
}
|
|
} else if (isPropertyCall("Object", "defineProperties", node.parent.parent.parent.parent)) {
|
|
propertyName = node.parent.parent.key.name;
|
|
if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
|
|
report(node, propertyName, functionName, true);
|
|
}
|
|
} else if (isPropertyCall("Object", "create", node.parent.parent.parent.parent)) {
|
|
propertyName = node.parent.parent.key.name;
|
|
if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
|
|
report(node, propertyName, functionName, true);
|
|
}
|
|
} else if (shouldWarn(propertyName, functionName)) {
|
|
report(node, propertyName, functionName, true);
|
|
}
|
|
} else if (shouldWarn(propertyName, functionName)) {
|
|
report(node, propertyName, functionName, true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (
|
|
isStringLiteral(node.key) &&
|
|
isIdentifier(node.key.value, ecmaVersion) &&
|
|
shouldWarn(node.key.value, node.value.id.name)
|
|
) {
|
|
report(node, node.key.value, node.value.id.name, true);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
};
|