ok
Mini Shell
# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
"""Module to add McCabe checker class for pylint."""
from __future__ import annotations
from collections.abc import Sequence
from typing import TYPE_CHECKING, Any, TypeVar, Union
from astroid import nodes
from mccabe import PathGraph as Mccabe_PathGraph
from mccabe import PathGraphingAstVisitor as Mccabe_PathGraphingAstVisitor
from pylint import checkers
from pylint.checkers.utils import only_required_for_messages
from pylint.interfaces import HIGH
if TYPE_CHECKING:
from pylint.lint import PyLinter
_StatementNodes = Union[
nodes.Assert,
nodes.Assign,
nodes.AugAssign,
nodes.Delete,
nodes.Raise,
nodes.Yield,
nodes.Import,
nodes.Call,
nodes.Subscript,
nodes.Pass,
nodes.Continue,
nodes.Break,
nodes.Global,
nodes.Return,
nodes.Expr,
nodes.Await,
]
_SubGraphNodes = Union[nodes.If, nodes.TryExcept, nodes.For, nodes.While]
_AppendableNodeT = TypeVar(
"_AppendableNodeT", bound=Union[_StatementNodes, nodes.While, nodes.FunctionDef]
)
class PathGraph(Mccabe_PathGraph): # type: ignore[misc]
def __init__(self, node: _SubGraphNodes | nodes.FunctionDef):
super().__init__(name="", entity="", lineno=1)
self.root = node
class PathGraphingAstVisitor(Mccabe_PathGraphingAstVisitor): # type: ignore[misc]
def __init__(self) -> None:
super().__init__()
self._bottom_counter = 0
self.graph: PathGraph | None = None
def default(self, node: nodes.NodeNG, *args: Any) -> None:
for child in node.get_children():
self.dispatch(child, *args)
def dispatch(self, node: nodes.NodeNG, *args: Any) -> Any:
self.node = node
klass = node.__class__
meth = self._cache.get(klass)
if meth is None:
class_name = klass.__name__
meth = getattr(self.visitor, "visit" + class_name, self.default)
self._cache[klass] = meth
return meth(node, *args)
def visitFunctionDef(self, node: nodes.FunctionDef) -> None:
if self.graph is not None:
# closure
pathnode = self._append_node(node)
self.tail = pathnode
self.dispatch_list(node.body)
bottom = f"{self._bottom_counter}"
self._bottom_counter += 1
self.graph.connect(self.tail, bottom)
self.graph.connect(node, bottom)
self.tail = bottom
else:
self.graph = PathGraph(node)
self.tail = node
self.dispatch_list(node.body)
self.graphs[f"{self.classname}{node.name}"] = self.graph
self.reset()
visitAsyncFunctionDef = visitFunctionDef
def visitSimpleStatement(self, node: _StatementNodes) -> None:
self._append_node(node)
visitAssert = (
visitAssign
) = (
visitAugAssign
) = (
visitDelete
) = (
visitRaise
) = (
visitYield
) = (
visitImport
) = (
visitCall
) = (
visitSubscript
) = (
visitPass
) = (
visitContinue
) = (
visitBreak
) = visitGlobal = visitReturn = visitExpr = visitAwait = visitSimpleStatement
def visitWith(self, node: nodes.With) -> None:
self._append_node(node)
self.dispatch_list(node.body)
visitAsyncWith = visitWith
def _append_node(self, node: _AppendableNodeT) -> _AppendableNodeT | None:
if not self.tail or not self.graph:
return None
self.graph.connect(self.tail, node)
self.tail = node
return node
def _subgraph(
self,
node: _SubGraphNodes,
name: str,
extra_blocks: Sequence[nodes.ExceptHandler] = (),
) -> None:
"""Create the subgraphs representing any `if` and `for` statements."""
if self.graph is None:
# global loop
self.graph = PathGraph(node)
self._subgraph_parse(node, node, extra_blocks)
self.graphs[f"{self.classname}{name}"] = self.graph
self.reset()
else:
self._append_node(node)
self._subgraph_parse(node, node, extra_blocks)
def _subgraph_parse(
self,
node: _SubGraphNodes,
pathnode: _SubGraphNodes,
extra_blocks: Sequence[nodes.ExceptHandler],
) -> None:
"""Parse the body and any `else` block of `if` and `for` statements."""
loose_ends = []
self.tail = node
self.dispatch_list(node.body)
loose_ends.append(self.tail)
for extra in extra_blocks:
self.tail = node
self.dispatch_list(extra.body)
loose_ends.append(self.tail)
if node.orelse:
self.tail = node
self.dispatch_list(node.orelse)
loose_ends.append(self.tail)
else:
loose_ends.append(node)
if node and self.graph:
bottom = f"{self._bottom_counter}"
self._bottom_counter += 1
for end in loose_ends:
self.graph.connect(end, bottom)
self.tail = bottom
class McCabeMethodChecker(checkers.BaseChecker):
"""Checks McCabe complexity cyclomatic threshold in methods and functions
to validate a too complex code.
"""
name = "design"
msgs = {
"R1260": (
"%s is too complex. The McCabe rating is %d",
"too-complex",
"Used when a method or function is too complex based on "
"McCabe Complexity Cyclomatic",
)
}
options = (
(
"max-complexity",
{
"default": 10,
"type": "int",
"metavar": "<int>",
"help": "McCabe complexity cyclomatic threshold",
},
),
)
@only_required_for_messages("too-complex")
def visit_module(self, node: nodes.Module) -> None:
"""Visit an astroid.Module node to check too complex rating and
add message if is greater than max_complexity stored from options.
"""
visitor = PathGraphingAstVisitor()
for child in node.body:
visitor.preorder(child, visitor)
for graph in visitor.graphs.values():
complexity = graph.complexity()
node = graph.root
if hasattr(node, "name"):
node_name = f"'{node.name}'"
else:
node_name = f"This '{node.__class__.__name__.lower()}'"
if complexity <= self.linter.config.max_complexity:
continue
self.add_message(
"too-complex", node=node, confidence=HIGH, args=(node_name, complexity)
)
def register(linter: PyLinter) -> None:
linter.register_checker(McCabeMethodChecker(linter))
Zerion Mini Shell 1.0