flake8-elegant-objects 1.0.0__py3-none-any.whl

flake8_elegant_objects/no_implementation_inheritance.py

@@ -0,0 +1,75 @@
+"""No implementation inheritance principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoImplementationInheritance:
+    """Checks for implementation inheritance violations (EO014)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for implementation inheritance violations."""
+        node = source.node
+
+        if isinstance(node, ast.ClassDef):
+            return self._check_implementation_inheritance(node)
+
+        return []
+
+    def _check_implementation_inheritance(self, node: ast.ClassDef) -> Violations:
+        """Check for implementation inheritance violations."""
+        for base in node.bases:
+            is_abstract_base = False
+
+            if isinstance(base, ast.Name):
+                # Allow inheritance from abstract base classes and common patterns
+                allowed_bases = {
+                    # Abstract bases
+                    "ABC",
+                    "Protocol",
+                    # Exception hierarchy (standard pattern)
+                    "Exception",
+                    "BaseException",
+                    "ValueError",
+                    "TypeError",
+                    "RuntimeError",
+                    "AttributeError",
+                    "KeyError",
+                    "IndexError",
+                    "ImportError",
+                    "OSError",
+                    # Standard library abstract bases
+                    "Enum",
+                    "IntEnum",
+                    "Flag",
+                    "IntFlag",
+                    # Generic object (unavoidable in Python)
+                    "object",
+                }
+                is_abstract_base = base.id in allowed_bases
+
+            elif isinstance(base, ast.Attribute):
+                # Check for module.AbstractBase patterns
+                if base.attr in {"Protocol", "ABC"}:
+                    is_abstract_base = True
+                elif isinstance(base.value, ast.Name) and base.value.id in {
+                    "abc",
+                    "typing",
+                    "collections",
+                    "enum",
+                }:
+                    is_abstract_base = True
+                # Check for imported ABC/Protocol
+                elif isinstance(base.value, ast.Name) and base.attr in {
+                    "ABC",
+                    "abstractmethod",
+                    "Protocol",
+                }:
+                    is_abstract_base = True
+
+            # If not an abstract base, it's implementation inheritance
+            if not is_abstract_base:
+                return violation(node, ErrorCodes.EO014.format(name=node.name))
+
+        return []

flake8_elegant_objects/no_impure_tests.py

@@ -0,0 +1,127 @@
+"""No impure tests principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoImpureTests:
+    """Checks for impure test methods violations (EO012)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for impure test method violations."""
+        node = source.node
+
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            return self._check_test_methods(node)
+
+        return []
+
+    def _check_test_methods(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> Violations:
+        """Check that test methods only contain single assertion statements."""
+        if not node.name.startswith("test_"):
+            return []
+
+        violations = []
+        assertion_count = 0
+
+        for stmt in node.body:
+            if isinstance(stmt, ast.Pass):
+                continue  # Allow pass statements
+
+            elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+                # Check if it's an assertion
+                if self._is_assertion_call(stmt.value):
+                    assertion_count += 1
+                    continue
+                else:
+                    # Non-assertion expression call
+                    violations.extend(
+                        violation(stmt, ErrorCodes.EO012.format(name=node.name))
+                    )
+
+            elif isinstance(stmt, ast.Assert):
+                # Direct assert statement
+                assertion_count += 1
+                continue
+
+            elif isinstance(stmt, ast.With):
+                # Check for pytest.raises or similar context managers
+                if self._is_assertion_context_manager(stmt):
+                    assertion_count += 1
+                    continue
+                else:
+                    violations.extend(
+                        violation(stmt, ErrorCodes.EO012.format(name=node.name))
+                    )
+
+            else:
+                # Any other statement (assignments, etc.) is a violation
+                violations.extend(
+                    violation(stmt, ErrorCodes.EO012.format(name=node.name))
+                )
+
+        # Test must have exactly one assertion
+        if assertion_count == 0:
+            violations.extend(violation(node, ErrorCodes.EO012.format(name=node.name)))
+        elif assertion_count > 1:
+            violations.extend(violation(node, ErrorCodes.EO012.format(name=node.name)))
+
+        return violations
+
+    def _is_assertion_call(self, call: ast.Call) -> bool:
+        """Check if a call is an assertion."""
+        # Check for unittest style assertions (self.assertEqual, self.assertTrue, etc.)
+        if isinstance(call.func, ast.Attribute):
+            if call.func.attr.startswith("assert"):
+                return True
+            # Check for chained assertions like assertThat(...).isEqualTo(...)
+            if self._contains_assertion_in_chain(call):
+                return True
+
+        # Check for standalone assertion functions
+        if isinstance(call.func, ast.Name):
+            if call.func.id.startswith("assert") or call.func.id == "assertThat":
+                return True
+
+        return False
+
+    def _contains_assertion_in_chain(self, call: ast.Call) -> bool:
+        """Check if assertion exists anywhere in the call chain."""
+        current = call
+        while isinstance(current, ast.Call):
+            if isinstance(current.func, ast.Name):
+                if (
+                    current.func.id.startswith("assert")
+                    or current.func.id == "assertThat"
+                ):
+                    return True
+            elif isinstance(current.func, ast.Attribute):
+                if (
+                    current.func.attr.startswith("assert")
+                    or current.func.attr == "assertThat"
+                ):
+                    return True
+                # Move to the next level in the chain
+                if isinstance(current.func.value, ast.Call):
+                    current = current.func.value
+                else:
+                    break
+            else:
+                break
+        return False
+
+    def _is_assertion_context_manager(self, with_stmt: ast.With) -> bool:
+        """Check if with statement is for assertions like pytest.raises."""
+        for item in with_stmt.items:
+            if isinstance(item.context_expr, ast.Call):
+                if isinstance(item.context_expr.func, ast.Attribute):
+                    # Check for pytest.raises, unittest.assertRaises, etc.
+                    if item.context_expr.func.attr in {"raises", "assertRaises"}:
+                        return True
+                elif isinstance(item.context_expr.func, ast.Name):
+                    if item.context_expr.func.id in {"raises", "assertRaises"}:
+                        return True
+        return False

flake8_elegant_objects/no_mutable_objects.py

@@ -0,0 +1,69 @@
+"""No mutable objects principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoMutableObjects:
+    """Checks for mutable object violations (EO008)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for mutable object violations."""
+        node = source.node
+        if not isinstance(node, ast.ClassDef):
+            return []
+        return self._check_mutable_class(node)
+
+    def _check_mutable_class(self, node: ast.ClassDef) -> Violations:
+        """Check for mutable class violations."""
+        violations = []
+
+        # Look for @dataclass decorator without frozen=True
+        has_dataclass = False
+        has_frozen = False
+
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id == "dataclass":
+                has_dataclass = True
+            elif isinstance(decorator, ast.Call):
+                if (
+                    isinstance(decorator.func, ast.Name)
+                    and decorator.func.id == "dataclass"
+                ):
+                    has_dataclass = True
+                    # Check for frozen=True
+                    for keyword in decorator.keywords:
+                        if keyword.arg == "frozen" and isinstance(
+                            keyword.value, ast.Constant
+                        ):
+                            if keyword.value.value is True:
+                                has_frozen = True
+
+        # If it's a dataclass without frozen=True, it's mutable
+        if has_dataclass and not has_frozen:
+            violations.extend(violation(node, ErrorCodes.EO008.format(name=node.name)))
+
+        # Check for mutable instance attributes in class body
+        for stmt in node.body:
+            if isinstance(stmt, ast.Assign):
+                for target in stmt.targets:
+                    if isinstance(target, ast.Name):
+                        # This is a class attribute, check if it's mutable
+                        if self._is_mutable_type(stmt.value):
+                            violations.extend(
+                                violation(stmt, ErrorCodes.EO008.format(name=target.id))
+                            )
+
+        return violations
+
+    def _is_mutable_type(self, node: ast.AST) -> bool:
+        """Check if a node represents a mutable type."""
+        if isinstance(node, ast.List | ast.Dict | ast.Set):
+            return True
+
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            mutable_types = {"list", "dict", "set", "bytearray"}
+            return node.func.id in mutable_types
+
+        return False

flake8_elegant_objects/no_null.py

@@ -0,0 +1,50 @@
+"""No null principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoNull:
+    """Checks for None usage violations (EO005)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for None usage violations."""
+        node = source.node
+        if isinstance(node, ast.Constant) and node.value is None:
+            # Skip None in type annotations
+            if self._is_in_type_annotation(node, source.tree):
+                return []
+            return violation(node, ErrorCodes.EO005)
+        return []
+
+    def _is_in_type_annotation(
+        self, target_node: ast.AST, tree: ast.AST | None
+    ) -> bool:
+        """Check if the target node is within a type annotation context."""
+        if not tree:
+            return False
+
+        # Find all annotation contexts in the tree
+        for node in ast.walk(tree):
+            # Function return annotations
+            if (
+                isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+                and node.returns
+            ):
+                if self._node_in_subtree(target_node, node.returns):
+                    return True
+            # Parameter annotations
+            elif isinstance(node, ast.arg) and node.annotation:
+                if self._node_in_subtree(target_node, node.annotation):
+                    return True
+            # Variable annotations
+            elif isinstance(node, ast.AnnAssign) and node.annotation:
+                if self._node_in_subtree(target_node, node.annotation):
+                    return True
+
+        return False
+
+    def _node_in_subtree(self, target: ast.AST, tree: ast.AST) -> bool:
+        """Check if target node is within the tree."""
+        return any(child is target for child in ast.walk(tree))

flake8_elegant_objects/no_orm.py

@@ -0,0 +1,97 @@
+"""No ORM principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoOrm:
+    """Checks for ORM/ActiveRecord pattern violations (EO013)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for ORM pattern violations."""
+        node = source.node
+
+        if isinstance(node, ast.Call):
+            return self._check_orm_patterns(node)
+
+        return []
+
+    def _check_orm_patterns(self, node: ast.Call) -> Violations:
+        """Check for ORM/ActiveRecord patterns."""
+        if not isinstance(node.func, ast.Attribute):
+            return []
+
+        orm_methods = {
+            "save",
+            "delete",
+            "destroy",
+            "update",
+            "create",
+            "reload",
+            "find",
+            "find_by",
+            "where",
+            "filter",
+            "filter_by",
+            "get",
+            "get_or_create",
+            "select",
+            "insert",
+            "update_all",
+            "delete_all",
+            "execute",
+            "query",
+            "order_by",
+            "group_by",
+            "having",
+            "limit",
+            "offset",
+            "join",
+            "includes",
+            "eager_load",
+            "preload",
+            "create_table",
+            "drop_table",
+            "add_column",
+            "remove_column",
+        }
+        if node.func.attr not in orm_methods:
+            return []
+
+        # Check if this is a valid non-ORM usage
+        if self._is_allowed_method_usage(node.func.value):
+            return []
+
+        return violation(node, ErrorCodes.EO013.format(name=node.func.attr))
+
+    def _is_allowed_method_usage(self, value: ast.AST) -> bool:
+        """Check if the method usage is allowed (not ORM)."""
+        # Built-in types
+        if isinstance(value, ast.Name) and value.id in {
+            "list",
+            "dict",
+            "set",
+            "tuple",
+            "str",
+            "int",
+            "float",
+            "bool",
+        }:
+            return True
+
+        # Allow methods on list/dict variables
+        if isinstance(value, ast.Name) and value.id.endswith("_list"):
+            return True
+
+        # Literal values
+        if isinstance(value, ast.Constant | ast.List | ast.Dict | ast.Tuple | ast.Set):
+            return True
+
+        # Constructor calls
+        return (
+            isinstance(value, ast.Call)
+            and isinstance(value.func, ast.Name)
+            and value.func.id
+            in {"open", "int", "str", "list", "dict", "set", "tuple", "bool", "float"}
+        )

flake8_elegant_objects/no_public_methods_without_contracts.py

@@ -0,0 +1,125 @@
+"""No public methods without contracts principle checker for Python."""
+
+import ast
+
+from .base import ErrorCodes, Principle, Source, Violations, is_method, violation
+
+
+class NoPublicMethodsWithoutContracts(Principle):
+    """Check that public methods are defined by contracts (Protocol/ABC)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check for public methods without contracts."""
+        violations: Violations = []
+
+        if not isinstance(source.node, ast.FunctionDef):
+            return violations
+
+        if not source.current_class or not is_method(source.node):
+            return violations
+
+        if source.node.name.startswith("_"):
+            return violations
+
+        if source.node.name.startswith("__") and source.node.name.endswith("__"):
+            return violations
+        if self._class_has_contract(source.current_class, source.tree):
+            if not self._method_from_contract(
+                source.node.name, source.current_class, source.tree
+            ):
+                violations.extend(
+                    violation(
+                        source.node, ErrorCodes.EO011.format(name=source.node.name)
+                    )
+                )
+        else:
+            violations.extend(
+                violation(source.node, ErrorCodes.EO011.format(name=source.node.name))
+            )
+
+        return violations
+
+    def _class_has_contract(
+        self, class_node: ast.ClassDef, tree: ast.AST | None
+    ) -> bool:
+        """Check if class implements any Protocol or ABC."""
+        if not class_node.bases:
+            return False
+
+        for base in class_node.bases:
+            base_name = self._get_base_name(base)
+            if not base_name:
+                continue
+
+            if self._is_protocol_or_abc(base_name, tree):
+                return True
+
+        return False
+
+    def _method_from_contract(
+        self, method_name: str, class_node: ast.ClassDef, tree: ast.AST | None
+    ) -> bool:
+        """Check if method is defined in any of the class's contracts."""
+        for base in class_node.bases:
+            base_name = self._get_base_name(base)
+            if not base_name:
+                continue
+
+            base_class = self._find_class_def(base_name, tree)
+            if not base_class:
+                if self._is_protocol_or_abc(base_name, tree):
+                    return True
+                continue
+
+            if self._has_method(base_class, method_name):
+                if self._is_protocol_or_abc(base_name, tree):
+                    return True
+
+        return False
+
+    def _get_base_name(self, base: ast.expr) -> str | None:
+        """Extract base class name from AST node."""
+        if isinstance(base, ast.Name):
+            return base.id
+        elif isinstance(base, ast.Attribute):
+            return base.attr
+        return None
+
+    def _is_protocol_or_abc(self, class_name: str, tree: ast.AST | None) -> bool:
+        """Check if a class is a Protocol or ABC."""
+        if class_name in ("Protocol", "ABC", "ABCMeta"):
+            return True
+
+        if class_name.endswith("Protocol") or class_name.endswith("ABC"):
+            return True
+
+        if tree:
+            class_def = self._find_class_def(class_name, tree)
+            if class_def:
+                for base in class_def.bases:
+                    base_name = self._get_base_name(base)
+                    if base_name and self._is_protocol_or_abc(base_name, None):
+                        return True
+
+        return False
+
+    def _find_class_def(
+        self, class_name: str, tree: ast.AST | None
+    ) -> ast.ClassDef | None:
+        """Find class definition in the AST tree."""
+        if not tree:
+            return None
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef) and node.name == class_name:
+                return node
+
+        return None
+
+    def _has_method(self, class_node: ast.ClassDef, method_name: str) -> bool:
+        """Check if class has a method with given name."""
+        for node in class_node.body:
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+                if node.name == method_name:
+                    return True
+        return False

flake8_elegant_objects/no_static.py

@@ -0,0 +1,31 @@
+"""No static methods principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoStatic:
+    """Checks for static method violations (EO009)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for static method violations."""
+        node = source.node
+
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            return self._check_static_methods(node)
+
+        return []
+
+    def _check_static_methods(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> Violations:
+        """Check for static methods violations."""
+        # Check for @staticmethod decorator
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id in {
+                "staticmethod",
+                "classmethod",
+            }:
+                return violation(node, ErrorCodes.EO009.format(name=node.name))
+        return []

flake8_elegant_objects/no_type_discrimination.py

@@ -0,0 +1,34 @@
+"""No type discrimination principle checker for Elegant Objects violations."""
+
+import ast
+
+from .base import ErrorCodes, Source, Violations, violation
+
+
+class NoTypeDiscrimination:
+    """Checks for type discrimination violations (EO010)."""
+
+    def check(self, source: Source) -> Violations:
+        """Check source for type discrimination violations."""
+        node = source.node
+
+        if isinstance(node, ast.Call):
+            return self._check_isinstance_usage(node)
+
+        return []
+
+    def _check_isinstance_usage(self, node: ast.Call) -> Violations:
+        """Check for isinstance, type casting, or reflection usage."""
+        if isinstance(node.func, ast.Name):
+            forbidden_funcs = {
+                "isinstance",
+                "type",
+                "hasattr",
+                "getattr",
+                "setattr",
+                "delattr",
+                "callable",
+            }
+            if node.func.id in forbidden_funcs:
+                return violation(node, ErrorCodes.EO010)
+        return []