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

rude_clean_code-0.2.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.2.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.2.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: rude-clean-code
+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
+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 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.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.2.0/features/deterministic_rules.feature

@@ -0,0 +1,31 @@
+Feature: Deterministic Clean Code core rules
+  Scenario: Rude discovers Clean Code rules via entry point
+    Given the rude-clean-code plugin is installed
+    When Rude discovers plugin rules
+    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
+    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 Clean Code rules on the package source
+    Given the rude-clean-code plugin is installed
+    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.2.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.2.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling>=1.27,<1.30"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rude-clean-code"
+version = "0.2.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 = ["CC0", "CC1", "CC2", "CC3"]
+
+[tool.rude.rules.CC002]
+allowed_names = ["VERSION"]

rude_clean_code-0.2.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.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.2.0/src/rude_clean_code/plugin.py

@@ -0,0 +1,30 @@
+"""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.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"]

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

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