325 lines
12 KiB
JavaScript
325 lines
12 KiB
JavaScript
/**
|
|
* @fileoverview Rule to flag non-camelcased identifiers
|
|
* @author Nicholas C. Zakas
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
module.exports = {
|
|
meta: {
|
|
type: "suggestion",
|
|
|
|
docs: {
|
|
description: "enforce camelcase naming convention",
|
|
category: "Stylistic Issues",
|
|
recommended: false,
|
|
url: "https://eslint.org/docs/rules/camelcase"
|
|
},
|
|
|
|
schema: [
|
|
{
|
|
type: "object",
|
|
properties: {
|
|
ignoreDestructuring: {
|
|
type: "boolean",
|
|
default: false
|
|
},
|
|
ignoreImports: {
|
|
type: "boolean",
|
|
default: false
|
|
},
|
|
ignoreGlobals: {
|
|
type: "boolean",
|
|
default: false
|
|
},
|
|
properties: {
|
|
enum: ["always", "never"]
|
|
},
|
|
allow: {
|
|
type: "array",
|
|
items: [
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
minItems: 0,
|
|
uniqueItems: true
|
|
}
|
|
},
|
|
additionalProperties: false
|
|
}
|
|
],
|
|
|
|
messages: {
|
|
notCamelCase: "Identifier '{{name}}' is not in camel case."
|
|
}
|
|
},
|
|
|
|
create(context) {
|
|
|
|
const options = context.options[0] || {};
|
|
let properties = options.properties || "";
|
|
const ignoreDestructuring = options.ignoreDestructuring;
|
|
const ignoreImports = options.ignoreImports;
|
|
const ignoreGlobals = options.ignoreGlobals;
|
|
const allow = options.allow || [];
|
|
|
|
let globalScope;
|
|
|
|
if (properties !== "always" && properties !== "never") {
|
|
properties = "always";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Helpers
|
|
//--------------------------------------------------------------------------
|
|
|
|
// contains reported nodes to avoid reporting twice on destructuring with shorthand notation
|
|
const reported = [];
|
|
const ALLOWED_PARENT_TYPES = new Set(["CallExpression", "NewExpression"]);
|
|
|
|
/**
|
|
* Checks if a string contains an underscore and isn't all upper-case
|
|
* @param {string} name The string to check.
|
|
* @returns {boolean} if the string is underscored
|
|
* @private
|
|
*/
|
|
function isUnderscored(name) {
|
|
|
|
// if there's an underscore, it might be A_CONSTANT, which is okay
|
|
return name.includes("_") && name !== name.toUpperCase();
|
|
}
|
|
|
|
/**
|
|
* Checks if a string match the ignore list
|
|
* @param {string} name The string to check.
|
|
* @returns {boolean} if the string is ignored
|
|
* @private
|
|
*/
|
|
function isAllowed(name) {
|
|
return allow.some(
|
|
entry => name === entry || name.match(new RegExp(entry, "u"))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks if a parent of a node is an ObjectPattern.
|
|
* @param {ASTNode} node The node to check.
|
|
* @returns {boolean} if the node is inside an ObjectPattern
|
|
* @private
|
|
*/
|
|
function isInsideObjectPattern(node) {
|
|
let current = node;
|
|
|
|
while (current) {
|
|
const parent = current.parent;
|
|
|
|
if (parent && parent.type === "Property" && parent.computed && parent.key === current) {
|
|
return false;
|
|
}
|
|
|
|
if (current.type === "ObjectPattern") {
|
|
return true;
|
|
}
|
|
|
|
current = parent;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks whether the given node represents assignment target property in destructuring.
|
|
*
|
|
* For examples:
|
|
* ({a: b.foo} = c); // => true for `foo`
|
|
* ([a.foo] = b); // => true for `foo`
|
|
* ([a.foo = 1] = b); // => true for `foo`
|
|
* ({...a.foo} = b); // => true for `foo`
|
|
* @param {ASTNode} node An Identifier node to check
|
|
* @returns {boolean} True if the node is an assignment target property in destructuring.
|
|
*/
|
|
function isAssignmentTargetPropertyInDestructuring(node) {
|
|
if (
|
|
node.parent.type === "MemberExpression" &&
|
|
node.parent.property === node &&
|
|
!node.parent.computed
|
|
) {
|
|
const effectiveParent = node.parent.parent;
|
|
|
|
return (
|
|
effectiveParent.type === "Property" &&
|
|
effectiveParent.value === node.parent &&
|
|
effectiveParent.parent.type === "ObjectPattern" ||
|
|
effectiveParent.type === "ArrayPattern" ||
|
|
effectiveParent.type === "RestElement" ||
|
|
(
|
|
effectiveParent.type === "AssignmentPattern" &&
|
|
effectiveParent.left === node.parent
|
|
)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
|
|
* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
|
|
* @param {ASTNode} node `Identifier` node to check.
|
|
* @returns {boolean} `true` if the node is a reference to a global variable.
|
|
*/
|
|
function isReferenceToGlobalVariable(node) {
|
|
const variable = globalScope.set.get(node.name);
|
|
|
|
return variable && variable.defs.length === 0 &&
|
|
variable.references.some(ref => ref.identifier === node);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the given node represents a reference to a property of an object in an object literal expression.
|
|
* This allows to differentiate between a global variable that is allowed to be used as a reference, and the key
|
|
* of the expressed object (which shouldn't be allowed).
|
|
* @param {ASTNode} node `Identifier` node to check.
|
|
* @returns {boolean} `true` if the node is a property name of an object literal expression
|
|
*/
|
|
function isPropertyNameInObjectLiteral(node) {
|
|
const parent = node.parent;
|
|
|
|
return (
|
|
parent.type === "Property" &&
|
|
parent.parent.type === "ObjectExpression" &&
|
|
!parent.computed &&
|
|
parent.key === node
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Reports an AST node as a rule violation.
|
|
* @param {ASTNode} node The node to report.
|
|
* @returns {void}
|
|
* @private
|
|
*/
|
|
function report(node) {
|
|
if (!reported.includes(node)) {
|
|
reported.push(node);
|
|
context.report({ node, messageId: "notCamelCase", data: { name: node.name } });
|
|
}
|
|
}
|
|
|
|
return {
|
|
|
|
Program() {
|
|
globalScope = context.getScope();
|
|
},
|
|
|
|
Identifier(node) {
|
|
|
|
/*
|
|
* Leading and trailing underscores are commonly used to flag
|
|
* private/protected identifiers, strip them before checking if underscored
|
|
*/
|
|
const name = node.name,
|
|
nameIsUnderscored = isUnderscored(name.replace(/^_+|_+$/gu, "")),
|
|
effectiveParent = (node.parent.type === "MemberExpression") ? node.parent.parent : node.parent;
|
|
|
|
// First, we ignore the node if it match the ignore list
|
|
if (isAllowed(name)) {
|
|
return;
|
|
}
|
|
|
|
// Check if it's a global variable
|
|
if (ignoreGlobals && isReferenceToGlobalVariable(node) && !isPropertyNameInObjectLiteral(node)) {
|
|
return;
|
|
}
|
|
|
|
// MemberExpressions get special rules
|
|
if (node.parent.type === "MemberExpression") {
|
|
|
|
// "never" check properties
|
|
if (properties === "never") {
|
|
return;
|
|
}
|
|
|
|
// Always report underscored object names
|
|
if (node.parent.object.type === "Identifier" && node.parent.object.name === node.name && nameIsUnderscored) {
|
|
report(node);
|
|
|
|
// Report AssignmentExpressions only if they are the left side of the assignment
|
|
} else if (effectiveParent.type === "AssignmentExpression" && nameIsUnderscored && (effectiveParent.right.type !== "MemberExpression" || effectiveParent.left.type === "MemberExpression" && effectiveParent.left.property.name === node.name)) {
|
|
report(node);
|
|
|
|
} else if (isAssignmentTargetPropertyInDestructuring(node) && nameIsUnderscored) {
|
|
report(node);
|
|
}
|
|
|
|
/*
|
|
* Properties have their own rules, and
|
|
* AssignmentPattern nodes can be treated like Properties:
|
|
* e.g.: const { no_camelcased = false } = bar;
|
|
*/
|
|
} else if (node.parent.type === "Property" || node.parent.type === "AssignmentPattern") {
|
|
|
|
if (node.parent.parent && node.parent.parent.type === "ObjectPattern") {
|
|
if (node.parent.shorthand && node.parent.value.left && nameIsUnderscored) {
|
|
report(node);
|
|
}
|
|
|
|
const assignmentKeyEqualsValue = node.parent.key.name === node.parent.value.name;
|
|
|
|
if (nameIsUnderscored && node.parent.computed) {
|
|
report(node);
|
|
}
|
|
|
|
// prevent checking righthand side of destructured object
|
|
if (node.parent.key === node && node.parent.value !== node) {
|
|
return;
|
|
}
|
|
|
|
const valueIsUnderscored = node.parent.value.name && nameIsUnderscored;
|
|
|
|
// ignore destructuring if the option is set, unless a new identifier is created
|
|
if (valueIsUnderscored && !(assignmentKeyEqualsValue && ignoreDestructuring)) {
|
|
report(node);
|
|
}
|
|
}
|
|
|
|
// "never" check properties or always ignore destructuring
|
|
if (properties === "never" || (ignoreDestructuring && isInsideObjectPattern(node))) {
|
|
return;
|
|
}
|
|
|
|
// don't check right hand side of AssignmentExpression to prevent duplicate warnings
|
|
if (nameIsUnderscored && !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && !(node.parent.right === node)) {
|
|
report(node);
|
|
}
|
|
|
|
// Check if it's an import specifier
|
|
} else if (["ImportSpecifier", "ImportNamespaceSpecifier", "ImportDefaultSpecifier"].includes(node.parent.type)) {
|
|
|
|
if (node.parent.type === "ImportSpecifier" && ignoreImports) {
|
|
return;
|
|
}
|
|
|
|
// Report only if the local imported identifier is underscored
|
|
if (
|
|
node.parent.local &&
|
|
node.parent.local.name === node.name &&
|
|
nameIsUnderscored
|
|
) {
|
|
report(node);
|
|
}
|
|
|
|
// Report anything that is underscored that isn't a CallExpression
|
|
} else if (nameIsUnderscored && !ALLOWED_PARENT_TYPES.has(effectiveParent.type)) {
|
|
report(node);
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
};
|