mirror of
https://github.com/joelwmale/webhook-action.git
synced 2024-12-05 05:34:29 +01:00
231 lines
6.9 KiB
JavaScript
231 lines
6.9 KiB
JavaScript
|
/**
|
||
|
* @fileoverview Rule that warns when identifier names that are
|
||
|
* specified in the configuration are used.
|
||
|
* @author Keith Cirkel (http://keithcirkel.co.uk)
|
||
|
*/
|
||
|
|
||
|
"use strict";
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// Helpers
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
/**
|
||
|
* Checks whether the given node represents assignment target in a normal assignment or destructuring.
|
||
|
* @param {ASTNode} node The node to check.
|
||
|
* @returns {boolean} `true` if the node is assignment target.
|
||
|
*/
|
||
|
function isAssignmentTarget(node) {
|
||
|
const parent = node.parent;
|
||
|
|
||
|
return (
|
||
|
|
||
|
// normal assignment
|
||
|
(
|
||
|
parent.type === "AssignmentExpression" &&
|
||
|
parent.left === node
|
||
|
) ||
|
||
|
|
||
|
// destructuring
|
||
|
parent.type === "ArrayPattern" ||
|
||
|
parent.type === "RestElement" ||
|
||
|
(
|
||
|
parent.type === "Property" &&
|
||
|
parent.value === node &&
|
||
|
parent.parent.type === "ObjectPattern"
|
||
|
) ||
|
||
|
(
|
||
|
parent.type === "AssignmentPattern" &&
|
||
|
parent.left === node
|
||
|
)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
|
||
|
*
|
||
|
* Examples:
|
||
|
* import { a as b } from 'mod'; // node `a` is renamed import
|
||
|
* export { a as b } from 'mod'; // node `a` is renamed import
|
||
|
* @param {ASTNode} node `Identifier` node to check.
|
||
|
* @returns {boolean} `true` if the node is a renamed import.
|
||
|
*/
|
||
|
function isRenamedImport(node) {
|
||
|
const parent = node.parent;
|
||
|
|
||
|
return (
|
||
|
(
|
||
|
parent.type === "ImportSpecifier" &&
|
||
|
parent.imported !== parent.local &&
|
||
|
parent.imported === node
|
||
|
) ||
|
||
|
(
|
||
|
parent.type === "ExportSpecifier" &&
|
||
|
parent.parent.source && // re-export
|
||
|
parent.local !== parent.exported &&
|
||
|
parent.local === node
|
||
|
)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
|
||
|
*
|
||
|
* Examples:
|
||
|
* const { a : b } = foo; // node `a` is renamed node.
|
||
|
* @param {ASTNode} node `Identifier` node to check.
|
||
|
* @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
|
||
|
*/
|
||
|
function isRenamedInDestructuring(node) {
|
||
|
const parent = node.parent;
|
||
|
|
||
|
return (
|
||
|
(
|
||
|
!parent.computed &&
|
||
|
parent.type === "Property" &&
|
||
|
parent.parent.type === "ObjectPattern" &&
|
||
|
parent.value !== node &&
|
||
|
parent.key === node
|
||
|
)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Checks whether the given node represents shorthand definition of a property in an object literal.
|
||
|
* @param {ASTNode} node `Identifier` node to check.
|
||
|
* @returns {boolean} `true` if the node is a shorthand property definition.
|
||
|
*/
|
||
|
function isShorthandPropertyDefinition(node) {
|
||
|
const parent = node.parent;
|
||
|
|
||
|
return (
|
||
|
parent.type === "Property" &&
|
||
|
parent.parent.type === "ObjectExpression" &&
|
||
|
parent.shorthand
|
||
|
);
|
||
|
}
|
||
|
|
||
|
//------------------------------------------------------------------------------
|
||
|
// Rule Definition
|
||
|
//------------------------------------------------------------------------------
|
||
|
|
||
|
module.exports = {
|
||
|
meta: {
|
||
|
type: "suggestion",
|
||
|
|
||
|
docs: {
|
||
|
description: "disallow specified identifiers",
|
||
|
category: "Stylistic Issues",
|
||
|
recommended: false,
|
||
|
url: "https://eslint.org/docs/rules/id-denylist"
|
||
|
},
|
||
|
|
||
|
schema: {
|
||
|
type: "array",
|
||
|
items: {
|
||
|
type: "string"
|
||
|
},
|
||
|
uniqueItems: true
|
||
|
},
|
||
|
messages: {
|
||
|
restricted: "Identifier '{{name}}' is restricted."
|
||
|
}
|
||
|
},
|
||
|
|
||
|
create(context) {
|
||
|
|
||
|
const denyList = new Set(context.options);
|
||
|
const reportedNodes = new Set();
|
||
|
|
||
|
let globalScope;
|
||
|
|
||
|
/**
|
||
|
* Checks whether the given name is restricted.
|
||
|
* @param {string} name The name to check.
|
||
|
* @returns {boolean} `true` if the name is restricted.
|
||
|
* @private
|
||
|
*/
|
||
|
function isRestricted(name) {
|
||
|
return denyList.has(name);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* 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);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Determines whether the given node should be checked.
|
||
|
* @param {ASTNode} node `Identifier` node.
|
||
|
* @returns {boolean} `true` if the node should be checked.
|
||
|
*/
|
||
|
function shouldCheck(node) {
|
||
|
const parent = node.parent;
|
||
|
|
||
|
/*
|
||
|
* Member access has special rules for checking property names.
|
||
|
* Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
|
||
|
* Write access isn't allowed, because it potentially creates a new property with a restricted name.
|
||
|
*/
|
||
|
if (
|
||
|
parent.type === "MemberExpression" &&
|
||
|
parent.property === node &&
|
||
|
!parent.computed
|
||
|
) {
|
||
|
return isAssignmentTarget(parent);
|
||
|
}
|
||
|
|
||
|
return (
|
||
|
parent.type !== "CallExpression" &&
|
||
|
parent.type !== "NewExpression" &&
|
||
|
!isRenamedImport(node) &&
|
||
|
!isRenamedInDestructuring(node) &&
|
||
|
!(
|
||
|
isReferenceToGlobalVariable(node) &&
|
||
|
!isShorthandPropertyDefinition(node)
|
||
|
)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Reports an AST node as a rule violation.
|
||
|
* @param {ASTNode} node The node to report.
|
||
|
* @returns {void}
|
||
|
* @private
|
||
|
*/
|
||
|
function report(node) {
|
||
|
if (!reportedNodes.has(node)) {
|
||
|
context.report({
|
||
|
node,
|
||
|
messageId: "restricted",
|
||
|
data: {
|
||
|
name: node.name
|
||
|
}
|
||
|
});
|
||
|
reportedNodes.add(node);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
|
||
|
Program() {
|
||
|
globalScope = context.getScope();
|
||
|
},
|
||
|
|
||
|
Identifier(node) {
|
||
|
if (isRestricted(node.name) && shouldCheck(node)) {
|
||
|
report(node);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
};
|