rude-clean-code 0.0.0__tar.gz → 0.1.0__tar.gz

rude_clean_code-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.egg-info/
+.pixi/
+.venv/
+dist/
+build/
+distributions/
+.coverage
+.coverage.*
+coverage.xml
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+node_modules/
+.tox/
+.doit.db*

rude_clean_code-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Archont561
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rude_clean_code-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: rude-clean-code
+Version: 0.1.0
+Summary: Clean Code plugin for the Rude Python linter.
+Project-URL: Homepage, https://github.com/Archont561/rude-clean-code#readme
+Project-URL: Documentation, https://github.com/Archont561/rude-clean-code/blob/main/docs/README.md
+Project-URL: Repository, https://github.com/Archont561/rude-clean-code
+Project-URL: Issues, https://github.com/Archont561/rude-clean-code/issues
+Project-URL: Changelog, https://github.com/Archont561/rude-clean-code/blob/main/CHANGELOG.md
+Author: Archont561
+License-Expression: MIT
+License-File: LICENSE
+Keywords: clean-code,code-quality,linter,rude,solid,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: rude<0.2,>=0.1a4
+Description-Content-Type: text/markdown
+
+# Rude Clean Code
+
+Clean Code plugin for the [Rude](https://pypi.org/project/rude/) Python linter,
+exposing deterministic size, parameter, scope, and complexity rules
+(`CC101`–`CC104`, `CC201`–`CC202`, `CC301`–`CC303`) through Rude's
+`rude.plugins` entry point.
+
+## Installation
+
+```sh
+pip install rude-clean-code
+```
+
+Rude discovers the plugin automatically via `rude.plugins` once installed.
+
+## Basic profile
+
+Add the **Basic** profile snippet to your `pyproject.toml`:
+
+```toml
+[tool.rude]
+select = ["CC1", "CC2", "CC3"]
+
+[tool.rude.rules.CC101]
+max_lines = 30
+```
+
+Run Rude from the command line:
+
+```sh
+rude check --select CC src/
+```
+
+All deterministic core rules report `WARNING` severity with measured value,
+configured limit, and a suggested refactoring action.
+
+## Implemented rules
+
+- **Functions (`CC1xx`)**: `CC101` (`max_lines = 30`), `CC102`
+  (`max_parameters = 5`), `CC103` (`max_returns = 5`), `CC104`
+  (`max_locals = 10`)
+- **Classes (`CC2xx`)**: `CC201` (`max_lines = 200`), `CC202`
+  (`max_methods = 15`)
+- **Complexity (`CC3xx`)**: `CC301` (`max_depth = 4`), `CC302`
+  (`max_operands = 3`), `CC303` (`max_branches = 10`)
+
+The package initializer `rude_clean_code` exposes only `VERSION` (read from
+installed distribution metadata); plugin rules live in `rude_clean_code.plugin`.
+
+See the
+[repository README](https://github.com/Archont561/rude-clean-code#readme) and
+[rule reference](https://github.com/Archont561/rude-clean-code/blob/main/docs/reference/rules.md)
+for full detection contracts, configuration options, and the backlog roadmap.

rude_clean_code-0.1.0/README.md

@@ -0,0 +1,53 @@
+# Rude Clean Code
+
+Clean Code plugin for the [Rude](https://pypi.org/project/rude/) Python linter,
+exposing deterministic size, parameter, scope, and complexity rules
+(`CC101`–`CC104`, `CC201`–`CC202`, `CC301`–`CC303`) through Rude's
+`rude.plugins` entry point.
+
+## Installation
+
+```sh
+pip install rude-clean-code
+```
+
+Rude discovers the plugin automatically via `rude.plugins` once installed.
+
+## Basic profile
+
+Add the **Basic** profile snippet to your `pyproject.toml`:
+
+```toml
+[tool.rude]
+select = ["CC1", "CC2", "CC3"]
+
+[tool.rude.rules.CC101]
+max_lines = 30
+```
+
+Run Rude from the command line:
+
+```sh
+rude check --select CC src/
+```
+
+All deterministic core rules report `WARNING` severity with measured value,
+configured limit, and a suggested refactoring action.
+
+## Implemented rules
+
+- **Functions (`CC1xx`)**: `CC101` (`max_lines = 30`), `CC102`
+  (`max_parameters = 5`), `CC103` (`max_returns = 5`), `CC104`
+  (`max_locals = 10`)
+- **Classes (`CC2xx`)**: `CC201` (`max_lines = 200`), `CC202`
+  (`max_methods = 15`)
+- **Complexity (`CC3xx`)**: `CC301` (`max_depth = 4`), `CC302`
+  (`max_operands = 3`), `CC303` (`max_branches = 10`)
+
+The package initializer `rude_clean_code` exposes only `VERSION` (read from
+installed distribution metadata); plugin rules live in `rude_clean_code.plugin`.
+
+See the
+[repository README](https://github.com/Archont561/rude-clean-code#readme) and
+[rule reference](https://github.com/Archont561/rude-clean-code/blob/main/docs/reference/rules.md)
+for full detection contracts, configuration options, and the backlog roadmap.

rude_clean_code-0.1.0/features/deterministic_rules.feature

@@ -0,0 +1,24 @@
+Feature: Deterministic Clean Code core rules
+  Scenario: Rude discovers deterministic Clean Code rules via entry point
+    Given the rude-clean-code plugin is installed
+    When Rude discovers plugin rules
+    Then all nine deterministic CC rules are available with WARNING severity
+    And selecting by CC, family prefix, or exact code filters the matching rules
+
+  Scenario: Consumer runs Basic profile and configured thresholds on Python code
+    Given a temporary project configured with the Basic profile
+    And a Python file violating deterministic CC rules and a clean nested function
+    When Rude checks the temporary project
+    Then diagnostics report measured value, configured limit, and suggested action as warnings
+    And Rude exits successfully without treating warnings as errors
+
+  Scenario: Consumer overrides a deterministic rule threshold in pyproject.toml
+    Given a temporary project setting CC101 max_lines to 4
+    And a Python function spanning 5 lines
+    When Rude checks the temporary project
+    Then Rude reports CC101 with measured 5 and limit 4
+
+  Scenario: Dogfooding deterministic CC rules on the package source
+    Given the rude-clean-code plugin is installed
+    When Rude checks the package source directory with CC selected
+    Then no CC diagnostics are emitted

rude_clean_code-0.1.0/features/package_version.feature

@@ -0,0 +1,8 @@
+Feature: Rude Clean Code package version discovery
+  Scenario: Discover the installed Rude Clean Code package version
+    Given the package is installed
+    When its root namespace is inspected
+    Then VERSION is its only public export
+    And VERSION matches pyproject and installed distribution metadata
+    And VERSION is read from distribution metadata
+    And importing the root namespace does not load rude or plugin submodules

rude_clean_code-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling>=1.27,<1.30"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rude-clean-code"
+version = "0.1.0"
+description = "Clean Code plugin for the Rude Python linter."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Archont561" }]
+keywords = ["rude", "linter", "clean-code", "solid", "static-analysis", "code-quality"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Quality Assurance",
+  "Typing :: Typed",
+]
+dependencies = [
+  "rude>=0.1a4,<0.2",
+]
+
+[project.entry-points."rude.plugins"]
+rude_clean_code = "rude_clean_code.plugin"
+
+[project.urls]
+Homepage = "https://github.com/Archont561/rude-clean-code#readme"
+Documentation = "https://github.com/Archont561/rude-clean-code/blob/main/docs/README.md"
+Repository = "https://github.com/Archont561/rude-clean-code"
+Issues = "https://github.com/Archont561/rude-clean-code/issues"
+Changelog = "https://github.com/Archont561/rude-clean-code/blob/main/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rude_clean_code"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/**",
+  "tests/**",
+  "features/**",
+  "/README.md",
+  "/LICENSE",
+]
+
+[tool.rude]
+select = ["CC1", "CC2", "CC3"]

rude_clean_code-0.1.0/src/rude_clean_code/__init__.py

@@ -0,0 +1,7 @@
+"""Rude Clean Code package version."""
+
+from importlib.metadata import version as _version
+
+VERSION = _version("rude-clean-code")
+
+__all__ = ["VERSION"]

rude_clean_code-0.1.0/src/rude_clean_code/_scope.py

@@ -0,0 +1,91 @@
+"""Shared own-scope AST traversal and threshold rule base helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from rude.core.rule import Rule
+from rude.core.types import Diagnostic, Severity
+
+if TYPE_CHECKING:
+    from rude.core.node import Node
+
+SCOPE_BOUNDARY_TYPES: frozenset[str] = frozenset(
+    {
+        "function_definition",
+        "class_definition",
+        "lambda",
+    }
+)
+
+
+def definition_name(node: Node) -> str:
+    """Return the readable name of a function or class definition node."""
+    return node.name or "<anonymous>"
+
+
+def iter_own_scope(root: Node) -> Iterator[Node]:
+    """Yield own-scope descendants without entering nested functions, classes, or lambdas."""
+    stack = list(reversed(root.named_children))
+    while stack:
+        current = stack.pop()
+        if current.type in SCOPE_BOUNDARY_TYPES:
+            continue
+        yield current
+        stack.extend(reversed(current.named_children))
+
+
+def max_own_scope_depth(root: Node, control_types: frozenset[str]) -> int:
+    """Return maximum nesting depth of *control_types* in *root*'s own scope."""
+    max_depth = 0
+    stack: list[tuple[Node, int]] = [
+        (child, 0) for child in reversed(root.named_children)
+    ]
+    while stack:
+        current, depth = stack.pop()
+        if current.type in SCOPE_BOUNDARY_TYPES:
+            continue
+        next_depth = depth + 1 if current.type in control_types else depth
+        max_depth = max(max_depth, next_depth)
+        stack.extend((child, next_depth) for child in reversed(current.named_children))
+    return max_depth
+
+
+class ThresholdRule(Rule):
+    """Base class for deterministic rules governed by one non-negative integer limit."""
+
+    severity: ClassVar[Severity | None] = Severity.WARNING
+    option_name: ClassVar[str]
+    default_limit: ClassVar[int]
+
+    def __init__(self) -> None:
+        setattr(self, self.option_name, self.default_limit)
+
+    @property
+    def limit(self) -> int:
+        """Configured upper bound (inclusive) for this rule."""
+        return int(getattr(self, self.option_name))
+
+    def configure(self, options: dict[str, Any]) -> None:
+        """Validate and apply the configured threshold from ``[tool.rude.rules.<CODE>]``."""
+        if self.option_name not in options:
+            return
+        raw = options[self.option_name]
+        if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
+            msg = (
+                f"{self.code} option '{self.option_name}' must be a "
+                f"non-negative integer, got {raw!r}"
+            )
+            raise ValueError(msg)
+        setattr(self, self.option_name, raw)
+
+    def emit_if_exceeds(
+        self,
+        node: Node,
+        measured: int,
+        message: str,
+    ) -> Iterator[Diagnostic]:
+        """Yield a diagnostic on *node* when *measured* exceeds the configured limit."""
+        if measured > self.limit:
+            yield self.diagnostic(node, message)

rude_clean_code-0.1.0/src/rude_clean_code/plugin.py

@@ -0,0 +1,20 @@
+"""Rude entry-point module exposing implemented Clean Code rules."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rude_clean_code.rules.classes import CLASS_RULES
+from rude_clean_code.rules.complexity import COMPLEXITY_RULES
+from rude_clean_code.rules.functions import FUNCTION_RULES
+
+if TYPE_CHECKING:
+    from rude.core.rule import Rule
+
+RULES: list[type[Rule]] = [
+    *FUNCTION_RULES,
+    *CLASS_RULES,
+    *COMPLEXITY_RULES,
+]
+
+__all__ = ["RULES"]

rude_clean_code-0.1.0/src/rude_clean_code/rules/__init__.py

@@ -0,0 +1 @@
+"""Rule implementations grouped by Clean Code family."""

rude_clean_code-0.1.0/src/rude_clean_code/rules/classes.py

@@ -0,0 +1,116 @@
+"""Deterministic Clean Code rules for classes (CC201-CC202)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, ClassVar
+
+from rude.core.node_types import NodeType
+
+from rude_clean_code._scope import ThresholdRule, definition_name
+
+if TYPE_CHECKING:
+    from rude.core.node import Node
+    from rude.core.types import Diagnostic
+
+
+def _is_dunder(name: str) -> bool:
+    return len(name) > 4 and name.startswith("__") and name.endswith("__")
+
+
+def _direct_method_node(child: Node) -> Node | None:
+    if child.type == "function_definition":
+        return child
+    if child.type == "decorated_definition":
+        definition = child.child_by_field("definition")
+        if definition is not None and definition.type == "function_definition":
+            return definition
+    return None
+
+
+def _count_direct_methods(body: Node) -> tuple[int, int]:
+    total = 0
+    dunders = 0
+    for child in body.named_children:
+        method = _direct_method_node(child)
+        if method is None:
+            continue
+        total += 1
+        if _is_dunder(definition_name(method)):
+            dunders += 1
+    return total, dunders
+
+
+class ClassTooLarge(ThresholdRule):
+    """CC201: Class spans too many lines.
+
+    Large classes tend to accumulate unrelated responsibilities. This size check
+    serves as an early prompt to inspect cohesion.
+
+    Configuration::
+
+        [tool.rude.rules.CC201]
+        max_lines = 200
+    """
+
+    code: ClassVar[str] = "CC201"
+    message: ClassVar[str] = "Class spans too many lines"
+    node_types: ClassVar[set[NodeType] | None] = {NodeType.CLASS_DEFINITION}
+    option_name: ClassVar[str] = "max_lines"
+    default_limit: ClassVar[int] = 200
+
+    def check(self, node: Node) -> Iterator[Diagnostic]:
+        """Flag class definitions spanning more lines than ``max_lines``."""
+        lines = node.end_line - node.line + 1
+        name = definition_name(node)
+        msg = (
+            f"Class '{name}' is too large ({lines} > {self.limit} lines); "
+            "extract cohesive helper classes or modules"
+        )
+        yield from self.emit_if_exceeds(node, lines, msg)
+
+
+class TooManyMethods(ThresholdRule):
+    """CC202: Class defines too many direct methods.
+
+    Classes exposing a large method surface often violate the Single
+    Responsibility Principle. Dunder protocol methods are included in the total
+    and counted separately in the diagnostic message for context.
+
+    Configuration::
+
+        [tool.rude.rules.CC202]
+        max_methods = 15
+    """
+
+    code: ClassVar[str] = "CC202"
+    message: ClassVar[str] = "Class defines too many direct methods"
+    node_types: ClassVar[set[NodeType] | None] = {NodeType.CLASS_DEFINITION}
+    option_name: ClassVar[str] = "max_methods"
+    default_limit: ClassVar[int] = 15
+
+    def check(self, node: Node) -> Iterator[Diagnostic]:
+        """Flag classes defining more direct methods than ``max_methods``."""
+        body = node.body
+        if body is None:
+            return
+        total, dunders = _count_direct_methods(body)
+        name = definition_name(node)
+        msg = (
+            f"Class '{name}' has too many methods "
+            f"({total} > {self.limit}, including {dunders} dunder); "
+            "extract cohesive collaborators or helper classes"
+        )
+        yield from self.emit_if_exceeds(node, total, msg)
+
+
+CLASS_RULES: list[type[ThresholdRule]] = [
+    ClassTooLarge,
+    TooManyMethods,
+]
+
+__all__ = [
+    "CLASS_RULES",
+    "ClassTooLarge",
+    "TooManyMethods",
+]

rude_clean_code-0.1.0/src/rude_clean_code/rules/complexity.py

@@ -0,0 +1,170 @@
+"""Deterministic Clean Code rules for control complexity (CC301-CC303)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, ClassVar
+
+from rude.core.node_types import NodeType
+
+from rude_clean_code._scope import (
+    ThresholdRule,
+    definition_name,
+    iter_own_scope,
+    max_own_scope_depth,
+)
+
+if TYPE_CHECKING:
+    from rude.core.node import Node
+    from rude.core.types import Diagnostic
+
+NESTING_NODE_TYPES: frozenset[str] = frozenset(
+    {
+        "if_statement",
+        "for_statement",
+        "while_statement",
+        "try_statement",
+        "with_statement",
+        "match_statement",
+    }
+)
+
+BRANCH_NODE_TYPES: frozenset[str] = frozenset(
+    {
+        "if_statement",
+        "elif_clause",
+        "for_statement",
+        "while_statement",
+        "boolean_operator",
+        "conditional_expression",
+        "case_clause",
+    }
+)
+
+
+def _count_boolean_operands(node: Node) -> int:
+    count = 0
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        for field in ("left", "right"):
+            operand = current.child_by_field(field)
+            if operand is None:
+                continue
+            if operand.type == "boolean_operator":
+                stack.append(operand)
+            else:
+                count += 1
+    return count
+
+
+class ExcessiveNesting(ThresholdRule):
+    """CC301: Function exceeds maximum control-structure nesting depth.
+
+    Deeply nested ``if``/``for``/``while``/``try``/``with``/``match`` blocks
+    increase cognitive load; flattening with guard clauses and helper functions
+    keeps intent obvious. Complements Rude's ``C901``.
+
+    Configuration::
+
+        [tool.rude.rules.CC301]
+        max_depth = 4
+    """
+
+    code: ClassVar[str] = "CC301"
+    message: ClassVar[str] = "Function exceeds maximum control nesting depth"
+    node_types: ClassVar[set[NodeType] | None] = {NodeType.FUNCTION_DEFINITION}
+    option_name: ClassVar[str] = "max_depth"
+    default_limit: ClassVar[int] = 4
+
+    def check(self, node: Node) -> Iterator[Diagnostic]:
+        """Flag functions whose deepest own-scope control nesting exceeds ``max_depth``."""
+        body = node.body
+        if body is None:
+            return
+        depth = max_own_scope_depth(body, NESTING_NODE_TYPES)
+        name = definition_name(node)
+        msg = (
+            f"Function '{name}' has excessive nesting depth ({depth} > {self.limit}); "
+            "use early returns or extract helpers"
+        )
+        yield from self.emit_if_exceeds(node, depth, msg)
+
+
+class ExcessiveBooleanOperands(ThresholdRule):
+    """CC302: Boolean expression combines too many operands.
+
+    Long ``and``/``or`` chains encode compound predicates that read far better as
+    named booleans or predicate helper functions. Complements Rude's ``C901``.
+
+    Configuration::
+
+        [tool.rude.rules.CC302]
+        max_operands = 3
+    """
+
+    code: ClassVar[str] = "CC302"
+    message: ClassVar[str] = "Boolean expression combines too many operands"
+    node_types: ClassVar[set[NodeType] | None] = {NodeType.BOOLEAN_OPERATOR}
+    option_name: ClassVar[str] = "max_operands"
+    default_limit: ClassVar[int] = 3
+
+    def check(self, node: Node) -> Iterator[Diagnostic]:
+        """Flag outermost boolean chains combining more than ``max_operands`` terms."""
+        if node.parent_type == "boolean_operator":
+            return
+        operands = _count_boolean_operands(node)
+        msg = (
+            f"Boolean expression has too many operands ({operands} > {self.limit}); "
+            "extract named predicate variables or helper functions"
+        )
+        yield from self.emit_if_exceeds(node, operands, msg)
+
+
+class ExcessiveBranching(ThresholdRule):
+    """CC303: Function contains too many decision points.
+
+    Counts own-scope ``if``, ``elif``, ``for``, ``while``, ``and``/``or``,
+    ternary expressions, and ``match`` cases. Intentionally distinct from and
+    complementary to Rude's ``C901``.
+
+    Configuration::
+
+        [tool.rude.rules.CC303]
+        max_branches = 10
+    """
+
+    code: ClassVar[str] = "CC303"
+    message: ClassVar[str] = "Function contains too many decision points"
+    node_types: ClassVar[set[NodeType] | None] = {NodeType.FUNCTION_DEFINITION}
+    option_name: ClassVar[str] = "max_branches"
+    default_limit: ClassVar[int] = 10
+
+    def check(self, node: Node) -> Iterator[Diagnostic]:
+        """Flag functions with more own-scope decision points than ``max_branches``."""
+        body = node.body
+        if body is None:
+            return
+        branches = sum(
+            1 for child in iter_own_scope(body) if child.type in BRANCH_NODE_TYPES
+        )
+        name = definition_name(node)
+        msg = (
+            f"Function '{name}' has too many branches ({branches} > {self.limit}); "
+            "decompose conditional logic or use dispatch"
+        )
+        yield from self.emit_if_exceeds(node, branches, msg)
+
+
+COMPLEXITY_RULES: list[type[ThresholdRule]] = [
+    ExcessiveNesting,
+    ExcessiveBooleanOperands,
+    ExcessiveBranching,
+]
+
+__all__ = [
+    "COMPLEXITY_RULES",
+    "ExcessiveBooleanOperands",
+    "ExcessiveBranching",
+    "ExcessiveNesting",
+]