pyrefactor 1.0.1__py3-none-any.whl

pyrefactor/config.py

@@ -0,0 +1,224 @@
+"""Configuration management for PyRefactor."""
+
+import configparser
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+
+@dataclass
+class ComplexityConfig:
+    """Configuration for complexity detector."""
+
+    max_branches: int = 10
+    max_nesting_depth: int = 3
+    max_function_lines: int = 50
+    max_arguments: int = 5
+    max_local_variables: int = 15
+    max_cyclomatic_complexity: int = 10
+
+
+@dataclass
+class PerformanceConfig:
+    """Configuration for performance detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class DuplicationConfig:
+    """Configuration for duplication detector."""
+
+    enabled: bool = True
+    min_duplicate_lines: int = 5
+    similarity_threshold: float = 0.85
+
+
+@dataclass
+class BooleanLogicConfig:
+    """Configuration for boolean logic detector."""
+
+    enabled: bool = True
+    max_boolean_operators: int = 3
+
+
+@dataclass
+class LoopsConfig:
+    """Configuration for loops detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class ContextManagerConfig:
+    """Configuration for context manager detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class ControlFlowConfig:
+    """Configuration for control flow detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class DictOperationsConfig:
+    """Configuration for dictionary operations detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class ComparisonsConfig:
+    """Configuration for comparisons detector."""
+
+    enabled: bool = True
+
+
+@dataclass
+class Config:
+    """Main configuration for PyRefactor."""
+
+    complexity: ComplexityConfig = field(default_factory=ComplexityConfig)
+    performance: PerformanceConfig = field(default_factory=PerformanceConfig)
+    duplication: DuplicationConfig = field(default_factory=DuplicationConfig)
+    boolean_logic: BooleanLogicConfig = field(default_factory=BooleanLogicConfig)
+    loops: LoopsConfig = field(default_factory=LoopsConfig)
+    context_manager: ContextManagerConfig = field(default_factory=ContextManagerConfig)
+    control_flow: ControlFlowConfig = field(default_factory=ControlFlowConfig)
+    dict_operations: DictOperationsConfig = field(default_factory=DictOperationsConfig)
+    comparisons: ComparisonsConfig = field(default_factory=ComparisonsConfig)
+    exclude_patterns: list[str] = field(default_factory=list)
+
+    @staticmethod
+    def _parse_complexity_config(config: configparser.ConfigParser) -> dict[str, int]:
+        """Extract complexity configuration from config parser."""
+        complexity_dict: dict[str, int] = {}
+        if config.has_section("complexity"):
+            for key in [
+                "max_branches",
+                "max_nesting_depth",
+                "max_function_lines",
+                "max_arguments",
+                "max_local_variables",
+                "max_cyclomatic_complexity",
+            ]:
+                if config.has_option("complexity", key):
+                    complexity_dict[key] = config.getint("complexity", key)
+        return complexity_dict
+
+    @staticmethod
+    def _parse_duplication_config(
+        config: configparser.ConfigParser,
+    ) -> dict[str, Union[int, float, bool]]:
+        """Extract duplication configuration from config parser."""
+        duplication_dict: dict[str, Union[int, float, bool]] = {}
+        if config.has_section("duplication"):
+            if config.has_option("duplication", "enabled"):
+                duplication_dict["enabled"] = config.getboolean(
+                    "duplication", "enabled"
+                )
+            if config.has_option("duplication", "min_duplicate_lines"):
+                duplication_dict["min_duplicate_lines"] = config.getint(
+                    "duplication", "min_duplicate_lines"
+                )
+            if config.has_option("duplication", "similarity_threshold"):
+                duplication_dict["similarity_threshold"] = config.getfloat(
+                    "duplication", "similarity_threshold"
+                )
+        return duplication_dict
+
+    @staticmethod
+    def _parse_boolean_logic_config(
+        config: configparser.ConfigParser,
+    ) -> dict[str, Union[int, bool]]:
+        """Extract boolean logic configuration from config parser."""
+        boolean_dict: dict[str, Union[int, bool]] = {}
+        if config.has_section("boolean_logic"):
+            if config.has_option("boolean_logic", "enabled"):
+                boolean_dict["enabled"] = config.getboolean("boolean_logic", "enabled")
+            if config.has_option("boolean_logic", "max_boolean_operators"):
+                boolean_dict["max_boolean_operators"] = config.getint(
+                    "boolean_logic", "max_boolean_operators"
+                )
+        return boolean_dict
+
+    @staticmethod
+    def _parse_enabled_flag(
+        config: configparser.ConfigParser, section: str
+    ) -> dict[str, bool]:
+        """Extract simple enabled flag from a config section."""
+        result: dict[str, bool] = {}
+        if config.has_section(section) and config.has_option(section, "enabled"):
+            result["enabled"] = config.getboolean(section, "enabled")
+        return result
+
+    @staticmethod
+    def _parse_exclude_patterns(config: configparser.ConfigParser) -> list[str]:
+        """Extract exclude patterns from config parser."""
+        exclude_list: list[str] = []
+        if config.has_section("general") and config.has_option(
+            "general", "exclude_patterns"
+        ):
+            patterns_str = config.get("general", "exclude_patterns")
+            # Parse comma-separated patterns
+            exclude_list = [
+                pattern.strip()
+                for pattern in patterns_str.split(",")
+                if pattern.strip()
+            ]
+        return exclude_list
+
+    @classmethod
+    def from_file(cls, config_path: Path) -> "Config":
+        """Load configuration from an INI file.
+
+        Technical note: This method works with dynamic INI data which mypy
+        cannot fully type-check. Type ignores are used to suppress Any-related
+        warnings while maintaining runtime safety through try-except handling.
+        """
+        try:
+            parser = configparser.ConfigParser()
+            parser.read(config_path, encoding="utf-8")
+
+            return cls(
+                complexity=ComplexityConfig(**cls._parse_complexity_config(parser)),
+                performance=PerformanceConfig(
+                    **cls._parse_enabled_flag(parser, "performance")
+                ),
+                duplication=DuplicationConfig(**cls._parse_duplication_config(parser)),  # type: ignore[arg-type]
+                boolean_logic=BooleanLogicConfig(**cls._parse_boolean_logic_config(parser)),  # type: ignore[arg-type]
+                loops=LoopsConfig(**cls._parse_enabled_flag(parser, "loops")),
+                context_manager=ContextManagerConfig(
+                    **cls._parse_enabled_flag(parser, "context_manager")
+                ),
+                control_flow=ControlFlowConfig(
+                    **cls._parse_enabled_flag(parser, "control_flow")
+                ),
+                dict_operations=DictOperationsConfig(
+                    **cls._parse_enabled_flag(parser, "dict_operations")
+                ),
+                comparisons=ComparisonsConfig(
+                    **cls._parse_enabled_flag(parser, "comparisons")
+                ),
+                exclude_patterns=cls._parse_exclude_patterns(parser),
+            )
+        except FileNotFoundError:
+            return cls()
+        except Exception as e:
+            raise ValueError(f"Error loading configuration: {e}") from e
+
+    @classmethod
+    def load(cls, config_path: Optional[Path] = None) -> "Config":
+        """Load configuration from file or use defaults."""
+        if config_path is not None:
+            return cls.from_file(config_path)
+
+        # Try to find pyrefactor.ini in current directory
+        ini_file = Path("pyrefactor.ini")
+        if ini_file.exists():
+            return cls.from_file(ini_file)
+
+        return cls()

pyrefactor/detectors/__init__.py

@@ -0,0 +1,23 @@
+"""Detector modules for PyRefactor."""
+
+from .boolean_logic import BooleanLogicDetector
+from .comparisons import ComparisonsDetector
+from .complexity import ComplexityDetector
+from .context_manager import ContextManagerDetector
+from .control_flow import ControlFlowDetector
+from .dict_operations import DictOperationsDetector
+from .duplication import DuplicationDetector
+from .loops import LoopsDetector
+from .performance import PerformanceDetector
+
+__all__ = [
+    "BooleanLogicDetector",
+    "ComparisonsDetector",
+    "ComplexityDetector",
+    "ContextManagerDetector",
+    "ControlFlowDetector",
+    "DictOperationsDetector",
+    "DuplicationDetector",
+    "LoopsDetector",
+    "PerformanceDetector",
+]

pyrefactor/detectors/boolean_logic.py

@@ -0,0 +1,231 @@
+"""Boolean logic detector for PyRefactor."""
+
+import ast
+from typing import Union, cast
+
+from ..ast_visitor import BaseDetector
+from ..models import Issue, Severity
+
+
+class BooleanLogicDetector(BaseDetector):
+    """Detects complex boolean logic that can be simplified."""
+
+    # Minimum nesting level to trigger early return suggestion
+    MIN_NESTING_FOR_EARLY_RETURN = 3
+
+    def get_detector_name(self) -> str:
+        """Return the name of this detector."""
+        return "boolean_logic"
+
+    def _create_issue(
+        self,
+        node: ast.AST,
+        *,
+        severity: Severity,
+        rule_id: str,
+        message: str,
+        suggestion: str,
+    ) -> Issue:
+        """Create an Issue object from common parameters."""
+        return Issue(
+            file=self.file_path,
+            line=cast(int, getattr(node, "lineno", 0)),
+            column=cast(int, getattr(node, "col_offset", 0)),
+            severity=severity,
+            rule_id=rule_id,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> None:
+        """Check for complex boolean operations."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        # Count total operators in the expression
+        operator_count = self._count_operators(node)
+        max_operators = self.config.boolean_logic.max_boolean_operators
+
+        if operator_count > max_operators:
+            self.add_issue(
+                self._create_issue(
+                    node,
+                    severity=Severity.MEDIUM,
+                    rule_id="B001",
+                    message=f"Complex boolean expression with {operator_count} operators (max {max_operators})",
+                    suggestion="Extract boolean sub-expressions to named variables for clarity",
+                )
+            )
+
+        self.generic_visit(node)
+
+    def visit_Compare(self, node: ast.Compare) -> None:
+        """Check for redundant boolean comparisons."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        # Check for comparison with True/False
+        for i, comparator in enumerate(node.comparators):
+            self._check_boolean_comparison(node, i, comparator)
+
+        self.generic_visit(node)
+
+    def _check_boolean_comparison(
+        self, node: ast.Compare, index: int, comparator: ast.expr
+    ) -> None:
+        """Check if a comparison involves a boolean constant.
+
+        Args:
+            node: The Compare node
+            index: Index of the comparator
+            comparator: The comparator expression
+        """
+        if not isinstance(comparator, ast.Constant):
+            return
+
+        if not isinstance(comparator.value, bool):
+            return
+
+        op = node.ops[index]
+        if isinstance(op, ast.Eq):
+            self._report_boolean_equality(node, comparator.value)
+        elif isinstance(op, ast.Is):
+            self._report_boolean_is(node)
+
+    def _report_boolean_equality(self, node: ast.Compare, value: bool) -> None:
+        """Report issues with boolean equality comparisons."""
+        rule_id, message, suggestion = (
+            (
+                "B002",
+                "Redundant comparison with True",
+                "Remove '== True' and use the boolean expression directly",
+            )
+            if value
+            else (
+                "B003",
+                "Redundant comparison with False",
+                "Use 'not expr' instead of 'expr == False'",
+            )
+        )
+        self.add_issue(
+            self._create_issue(
+                node,
+                severity=Severity.INFO,
+                rule_id=rule_id,
+                message=message,
+                suggestion=suggestion,
+            )
+        )
+
+    def _report_boolean_is(self, node: ast.Compare) -> None:
+        """Report issues with boolean 'is' comparisons."""
+        self.add_issue(
+            self._create_issue(
+                node,
+                severity=Severity.MEDIUM,
+                rule_id="B004",
+                message="Using 'is' for boolean comparison",
+                suggestion="Use '==' for value comparison or use the boolean directly",
+            )
+        )
+
+    def visit_FunctionDef(
+        self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]
+    ) -> None:
+        """Track function context for early return detection."""
+        old_function = self.current_function
+        self.current_function = node
+        self.generic_visit(node)
+        self.current_function = old_function
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Track async function context for early return detection."""
+        self.visit_FunctionDef(node)
+
+    def visit_If(self, node: ast.If) -> None:
+        """Check for opportunities to use early returns."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        # Check for nested if statements that could use early returns
+        if self.current_function:
+            self._check_early_return_opportunity(node)
+
+        self.generic_visit(node)
+
+    def _check_early_return_opportunity(self, node: ast.If) -> None:
+        """Check if nested ifs could benefit from early returns."""
+        # Look for pattern: if x: if y: if z: return
+        nesting_count = 0
+        current: ast.AST = node
+
+        while isinstance(current, ast.If):
+            nesting_count += 1
+            # Check if body contains only another If or a return
+            if len(current.body) != 1:
+                break
+
+            first_stmt = current.body[0]
+            if isinstance(first_stmt, ast.If):
+                current = first_stmt
+                continue
+
+            if isinstance(first_stmt, (ast.Return, ast.Raise)):
+                if nesting_count >= self.MIN_NESTING_FOR_EARLY_RETURN:
+                    self.add_issue(
+                        self._create_issue(
+                            node,
+                            severity=Severity.MEDIUM,
+                            rule_id="B005",
+                            message=f"Deeply nested if statements ({nesting_count} levels) with early exit",
+                            suggestion="Use guard clauses with early returns to reduce nesting",
+                        )
+                    )
+            break
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
+        """Check for De Morgan's law opportunities."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        # Check for not (a and b) or not (a or b)
+        if isinstance(node.op, ast.Not) and isinstance(node.operand, ast.BoolOp):
+            if isinstance(node.operand.op, (ast.And, ast.Or)):
+                rule_id, suggestion = (
+                    ("B006", "Replace 'not (a and b)' with 'not a or not b'")
+                    if isinstance(node.operand.op, ast.And)
+                    else ("B007", "Replace 'not (a or b)' with 'not a and not b'")
+                )
+                self.add_issue(
+                    self._create_issue(
+                        node,
+                        severity=Severity.INFO,
+                        rule_id=rule_id,
+                        message="Complex negation can be simplified using De Morgan's law",
+                        suggestion=suggestion,
+                    )
+                )
+
+        self.generic_visit(node)
+
+    def _count_operators(self, node: ast.BoolOp) -> int:
+        """Count the number of boolean operators in an expression.
+
+        Uses iterative approach for better performance on deeply nested expressions.
+        """
+        total_count = 0
+        stack = [node]
+
+        while stack:
+            current = stack.pop()
+            if isinstance(current, ast.BoolOp):
+                # n values require n-1 operators
+                total_count += len(current.values) - 1
+                # Add nested BoolOps to stack
+                stack.extend(v for v in current.values if isinstance(v, ast.BoolOp))
+
+        return total_count