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

{rude_clean_code-0.1.0 → rude_clean_code-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rude-clean-code
-Version: 0.1.0
+Version: 0.2.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
@@ -28,9 +28,10 @@ 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.
+exposing 26 Clean Code rules across module structure, functions, classes,
+complexity, error handling, naming/literals, same-file duplication, and
+polymorphism indicators (`CC001`–`CC601`) through Rude's `rude.plugins`
+entry point.
 
 ## Installation
 
@@ -40,13 +41,15 @@ pip install rude-clean-code
 
 Rude discovers the plugin automatically via `rude.plugins` once installed.
 
-## Basic profile
+## Configuration profiles
 
-Add the **Basic** profile snippet to your `pyproject.toml`:
+Add the **Basic** profile snippet (`CC0`–`CC3`) to your `pyproject.toml`, or
+include `"CC4"`, `"CC5"`, `"CC6"` for the **Strict** profile with heuristic
+indicators:
 
 ```toml
 [tool.rude]
-select = ["CC1", "CC2", "CC3"]
+select = ["CC0", "CC1", "CC2", "CC3"]
 
 [tool.rude.rules.CC101]
 max_lines = 30
@@ -55,21 +58,34 @@ max_lines = 30
 Run Rude from the command line:
 
 ```sh
-rude check --select CC src/
+rude check --select CC0,CC1,CC2,CC3 src/
 ```
 
-All deterministic core rules report `WARNING` severity with measured value,
-configured limit, and a suggested refactoring action.
+All `CC0xx`–`CC3xx` rules (except `CC002` at `INFO`), plus `CC403` and
+`CC501`, report `WARNING` severity; `CC002` and subjective indicator rules
+(`CC401`, `CC402`, `CC601`) report `INFO`.
 
 ## Implemented rules
 
+- **Modules (`CC0xx`)**: `CC001` (`max_lines = 400`), `CC002` (`__init__.py`
+  contains runtime logic), `CC003` (`__init__.py` missing `__all__`), `CC004`
+  (deep relative import, `max_relative_depth = 2`), `CC005` (private symbol
+  exported in `__all__`)
 - **Functions (`CC1xx`)**: `CC101` (`max_lines = 30`), `CC102`
   (`max_parameters = 5`), `CC103` (`max_returns = 5`), `CC104`
-  (`max_locals = 10`)
+  (`max_locals = 10`), `CC107` (unused private helper)
 - **Classes (`CC2xx`)**: `CC201` (`max_lines = 200`), `CC202`
-  (`max_methods = 15`)
-- **Complexity (`CC3xx`)**: `CC301` (`max_depth = 4`), `CC302`
-  (`max_operands = 3`), `CC303` (`max_branches = 10`)
+  (`max_methods = 15`), `CC207` (`max_bases = 3`)
+- **Complexity and error handling (`CC3xx`)**: `CC301` (`max_depth = 4`),
+  `CC302` (`max_operands = 3`), `CC303` (`max_branches = 10`), `CC306`
+  (nested ternary), `CC308` (`global` statement), `CC309` (broad exception
+  swallowed), `CC310` (missing exception chaining), `CC311` (`max_lines = 15`)
+- **In-file heuristics (`CC4xx`–`CC6xx`, Strict profile)**: `CC401`
+  (unclear function name), `CC402` (unclear class/variable name), `CC403`
+  (repeated magic literal, `min_occurrences = 3`), `CC501` (duplicate function
+  body within the **same file**, `min_lines = 5`; cross-file duplication is
+  planned as `CC502`), `CC601` (repeated `isinstance`/attribute switch,
+  `min_isinstance = 3`)
 
 The package initializer `rude_clean_code` exposes only `VERSION` (read from
 installed distribution metadata); plugin rules live in `rude_clean_code.plugin`.

rude_clean_code-0.2.0/README.md

@@ -0,0 +1,69 @@
+# Rude Clean Code
+
+Clean Code plugin for the [Rude](https://pypi.org/project/rude/) Python linter,
+exposing 26 Clean Code rules across module structure, functions, classes,
+complexity, error handling, naming/literals, same-file duplication, and
+polymorphism indicators (`CC001`–`CC601`) through Rude's `rude.plugins`
+entry point.
+
+## Installation
+
+```sh
+pip install rude-clean-code
+```
+
+Rude discovers the plugin automatically via `rude.plugins` once installed.
+
+## Configuration profiles
+
+Add the **Basic** profile snippet (`CC0`–`CC3`) to your `pyproject.toml`, or
+include `"CC4"`, `"CC5"`, `"CC6"` for the **Strict** profile with heuristic
+indicators:
+
+```toml
+[tool.rude]
+select = ["CC0", "CC1", "CC2", "CC3"]
+
+[tool.rude.rules.CC101]
+max_lines = 30
+```
+
+Run Rude from the command line:
+
+```sh
+rude check --select CC0,CC1,CC2,CC3 src/
+```
+
+All `CC0xx`–`CC3xx` rules (except `CC002` at `INFO`), plus `CC403` and
+`CC501`, report `WARNING` severity; `CC002` and subjective indicator rules
+(`CC401`, `CC402`, `CC601`) report `INFO`.
+
+## Implemented rules
+
+- **Modules (`CC0xx`)**: `CC001` (`max_lines = 400`), `CC002` (`__init__.py`
+  contains runtime logic), `CC003` (`__init__.py` missing `__all__`), `CC004`
+  (deep relative import, `max_relative_depth = 2`), `CC005` (private symbol
+  exported in `__all__`)
+- **Functions (`CC1xx`)**: `CC101` (`max_lines = 30`), `CC102`
+  (`max_parameters = 5`), `CC103` (`max_returns = 5`), `CC104`
+  (`max_locals = 10`), `CC107` (unused private helper)
+- **Classes (`CC2xx`)**: `CC201` (`max_lines = 200`), `CC202`
+  (`max_methods = 15`), `CC207` (`max_bases = 3`)
+- **Complexity and error handling (`CC3xx`)**: `CC301` (`max_depth = 4`),
+  `CC302` (`max_operands = 3`), `CC303` (`max_branches = 10`), `CC306`
+  (nested ternary), `CC308` (`global` statement), `CC309` (broad exception
+  swallowed), `CC310` (missing exception chaining), `CC311` (`max_lines = 15`)
+- **In-file heuristics (`CC4xx`–`CC6xx`, Strict profile)**: `CC401`
+  (unclear function name), `CC402` (unclear class/variable name), `CC403`
+  (repeated magic literal, `min_occurrences = 3`), `CC501` (duplicate function
+  body within the **same file**, `min_lines = 5`; cross-file duplication is
+  planned as `CC502`), `CC601` (repeated `isinstance`/attribute switch,
+  `min_isinstance = 3`)
+
+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 → rude_clean_code-0.2.0}/features/deterministic_rules.feature

@@ -1,8 +1,8 @@
 Feature: Deterministic Clean Code core rules
-  Scenario: Rude discovers deterministic Clean Code rules via entry point
+  Scenario: Rude discovers 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
+    Then all registered CC rules are available with their documented severities
     And selecting by CC, family prefix, or exact code filters the matching rules
 
   Scenario: Consumer runs Basic profile and configured thresholds on Python code
@@ -18,7 +18,14 @@ Feature: Deterministic Clean Code core rules
     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
+  Scenario: Dogfooding Clean Code rules on the package source
     Given the rude-clean-code plugin is installed
-    When Rude checks the package source directory with CC selected
+    When Rude checks the package source directory with the project Basic profile
     Then no CC diagnostics are emitted
+
+  Scenario: Consumer runs Strict profile including in-file heuristics
+    Given a temporary project configured with the Strict profile
+    And a Python file violating heuristic CC rules
+    When Rude checks the temporary project
+    Then Strict heuristic diagnostics carry expected severities and same-file guidance
+    And Rude exits successfully without treating warnings as errors

rude_clean_code-0.2.0/features/module_rules.feature

@@ -0,0 +1,24 @@
+Feature: Module and package organization Clean Code rules
+  Scenario: Oversized module receives a tailored non-autofix split suggestion
+    Given a temporary module project with CC001 max_lines set to 12
+    And a Python module with two separate symbol clusters exceeding 12 lines
+    When Rude runs CC0 checks on the module project
+    Then Rude reports CC001 without an autofix and suggests splitting by clusters
+
+  Scenario: Package initializer permits facade constructs and configured VERSION
+    Given a temporary module project checking CC002 with VERSION allowed
+    And a package initializer with VERSION, TYPE_CHECKING, __all__, and a helper function
+    When Rude runs CC0 checks on the module project
+    Then Rude flags only the helper function in __init__.py at INFO severity
+
+  Scenario: Non-empty initializer requires __all__ while marker files stay silent
+    Given a temporary module project checking CC003
+    And an empty marker __init__.py alongside a non-empty __init__.py missing __all__
+    When Rude runs CC0 checks on the module project
+    Then Rude flags only the non-empty __init__.py for missing __all__
+
+  Scenario: Deep relative imports and private __all__ exports are flagged
+    Given a temporary module project checking CC004 and CC005
+    And a module with a 3-dot relative import and __all__ containing a private name and a dunder
+    When Rude runs CC0 checks on the module project
+    Then Rude reports CC004 and CC005 while keeping __version__ exempt

{rude_clean_code-0.1.0 → rude_clean_code-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rude-clean-code"
-version = "0.1.0"
+version = "0.2.0"
 description = "Clean Code plugin for the Rude Python linter."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -51,4 +51,7 @@ include = [
 ]
 
 [tool.rude]
-select = ["CC1", "CC2", "CC3"]
+select = ["CC0", "CC1", "CC2", "CC3"]
+
+[tool.rude.rules.CC002]
+allowed_names = ["VERSION"]

rude_clean_code-0.2.0/src/rude_clean_code/_scope.py

@@ -0,0 +1,186 @@
+"""Shared own-scope AST traversal, option parsing, and rule base helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from fnmatch import fnmatch
+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
+    from rude.core.types import FileContext
+
+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 is_dunder(name: str) -> bool:
+    """Return whether *name* is a double-underscore Python dunder identifier."""
+    return len(name) > 4 and name.startswith("__") and name.endswith("__")
+
+
+def unwrap_decorated(node: Node) -> Node:
+    """Return the underlying definition when *node* is a ``decorated_definition``."""
+    if node.type != "decorated_definition":
+        return node
+    inner = node.child_by_field("definition")
+    if inner is not None:
+        return inner
+    for child in node.named_children:
+        if child.type != "decorator":
+            return child
+    return node
+
+
+def _decorator_target_names(decorator: Node) -> Iterator[str]:
+    for child in decorator.named_children:
+        target = child.child_by_field("function") if child.type == "call" else child
+        if target is None:
+            continue
+        text = target.text
+        if text:
+            yield text
+            if "." in text:
+                yield text.rsplit(".", maxsplit=1)[-1]
+
+
+def node_decorators(node: Node) -> list[str]:
+    """Return normalized decorator names attached to *node*'s ``decorated_definition``."""
+    parent = node.parent
+    if parent is None or parent.type != "decorated_definition":
+        return []
+    names: list[str] = []
+    for child in parent.named_children:
+        if child.type == "decorator":
+            names.extend(_decorator_target_names(child))
+    return names
+
+
+def is_test_context(context: FileContext) -> bool:
+    """Return whether *context* points to a test module or file inside a test folder."""
+    if context.is_test_file() or context.path.stem == "conftest":
+        return True
+    parent_parts = set(context.path.parts[:-1])
+    return "tests" in parent_parts or "test" in parent_parts
+
+
+def matches_exclude_paths(
+    context: FileContext,
+    patterns: tuple[str, ...],
+) -> bool:
+    """Return whether *context* matches any configured path fragment or glob."""
+    if not patterns:
+        return False
+    posix = context.path.as_posix()
+    return context.is_in_path(*patterns) or any(
+        fnmatch(posix, pattern) for pattern in patterns
+    )
+
+
+def _option_error(
+    code: str,
+    option_name: str,
+    expected: str,
+    raw: object,
+) -> ValueError:
+    return ValueError(f"{code} option '{option_name}' must be {expected}, got {raw!r}")
+
+
+def parse_nonneg_int(code: str, option_name: str, raw: object) -> int:
+    """Validate a non-negative integer rule option."""
+    if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
+        raise _option_error(code, option_name, "a non-negative integer", raw)
+    return raw
+
+
+def parse_bool_option(code: str, option_name: str, raw: object) -> bool:
+    """Validate a boolean rule option."""
+    if not isinstance(raw, bool):
+        raise _option_error(code, option_name, "a boolean", raw)
+    return raw
+
+
+def parse_str_list_option(
+    code: str,
+    option_name: str,
+    raw: object,
+) -> tuple[str, ...]:
+    """Validate a list/tuple-of-strings rule option and freeze it into a tuple."""
+    if not isinstance(raw, (list, tuple)) or any(
+        not isinstance(item, str) for item in raw
+    ):
+        raise _option_error(code, option_name, "a list of strings", raw)
+    return tuple(raw)
+
+
+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
+        value = parse_nonneg_int(self.code, self.option_name, options[self.option_name])
+        setattr(self, self.option_name, value)
+
+    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 → rude_clean_code-0.2.0}/src/rude_clean_code/plugin.py

@@ -6,15 +6,25 @@ 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.dry import DRY_RULES
+from rude_clean_code.rules.errors import ERROR_RULES
 from rude_clean_code.rules.functions import FUNCTION_RULES
+from rude_clean_code.rules.heuristics import HEURISTIC_RULES
+from rude_clean_code.rules.modules import MODULE_RULES
+from rude_clean_code.rules.naming import NAMING_RULES
 
 if TYPE_CHECKING:
     from rude.core.rule import Rule
 
 RULES: list[type[Rule]] = [
+    *MODULE_RULES,
     *FUNCTION_RULES,
     *CLASS_RULES,
     *COMPLEXITY_RULES,
+    *ERROR_RULES,
+    *NAMING_RULES,
+    *DRY_RULES,
+    *HEURISTIC_RULES,
 ]
 
 __all__ = ["RULES"]