pyrefactor 1.0.1__py3-none-any.whl

pyrefactor/detectors/performance.py

@@ -0,0 +1,267 @@
+"""Performance anti-pattern detector for PyRefactor."""
+
+import ast
+from typing import Optional, Union, cast
+
+from ..ast_visitor import BaseDetector
+from ..config import Config
+from ..models import Issue, Severity
+
+
+class PerformanceDetector(BaseDetector):
+    """Detects performance anti-patterns in code."""
+
+    # Type hint patterns for heuristic type detection
+    TYPE_HINTS: dict[str, list[str]] = {
+        "string": ["str", "text", "message", "name"],
+        "list": ["list", "items", "results", "array", "collection"],
+        "dict": ["dict", "map", "cache", "mapping"],
+    }
+
+    def __init__(self, config: Config, file_path: str, source_lines: list[str]) -> None:
+        """Initialize performance detector."""
+        super().__init__(config, file_path, source_lines)
+        self.in_loop = False
+        self.loop_stack: list[ast.AST] = []
+
+    def get_detector_name(self) -> str:
+        """Return the name of this detector."""
+        return "performance"
+
+    def _create_issue(
+        self,
+        node: ast.AST,
+        *,
+        severity: Severity,
+        rule_id: str,
+        message: str,
+        suggestion: str,
+    ) -> Issue:
+        """Create an Issue object for performance-related issues."""
+        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_loop(self, node: Union[ast.For, ast.While]) -> None:
+        """Consolidated method to track loop entry and exit."""
+        self.loop_stack.append(node)
+        self.in_loop = True
+        self.generic_visit(node)
+        self.loop_stack.pop()
+        self.in_loop = bool(self.loop_stack)
+
+    def visit_For(self, node: ast.For) -> None:
+        """Track when we're inside a for loop."""
+        self._visit_loop(node)
+
+    def visit_While(self, node: ast.While) -> None:
+        """Track when we're inside a while loop."""
+        self._visit_loop(node)
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> None:
+        """Check for inefficient augmented assignments in loops."""
+        if not self.in_loop or self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        # Check for string concatenation with +=
+        if not isinstance(node.op, ast.Add):
+            self.generic_visit(node)
+            return
+
+        if self._matches_type_hint(node.target, "string"):
+            self.add_issue(
+                self._create_issue(
+                    node,
+                    severity=Severity.MEDIUM,
+                    rule_id="P001",
+                    message="String concatenation in loop using += is inefficient",
+                    suggestion="Use str.join() with a list or io.StringIO for better performance",
+                )
+            )
+        # Check for list concatenation with +=
+        elif self._matches_type_hint(node.target, "list"):
+            self.add_issue(
+                self._create_issue(
+                    node,
+                    severity=Severity.LOW,
+                    rule_id="P002",
+                    message="List concatenation in loop using += may be inefficient",
+                    suggestion="Use list.extend() or list comprehension for better performance",
+                )
+            )
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Check for inefficient function calls."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        self._check_dict_keys_usage(node)
+        self._check_redundant_list_conversion(node)
+        self._check_len_usage(node)
+
+        self.generic_visit(node)
+
+    def _check_dict_keys_usage(self, node: ast.Call) -> None:
+        """Check for unnecessary dict.keys() in membership tests."""
+        if not isinstance(node.func, ast.Attribute):
+            return
+
+        if node.func.attr != "keys":
+            return
+
+        if not self._matches_type_hint(node.func.value, "dict"):
+            return
+
+        parent: Optional[ast.AST] = getattr(node, "_parent", None)
+        if not isinstance(parent, ast.Compare):
+            return
+
+        if not parent.ops or not isinstance(parent.ops[0], ast.In):
+            return
+
+        self.add_issue(  # pyrefactor: ignore
+            self._create_issue(
+                node,
+                severity=Severity.INFO,
+                rule_id="P003",
+                message="Unnecessary dict.keys() call in membership test",
+                suggestion="Use 'key in dict' instead of 'key in dict.keys()'",
+            )
+        )
+
+    def _check_redundant_list_conversion(self, node: ast.Call) -> None:
+        """Check for redundant list() conversions of list comprehensions."""
+        if not isinstance(node.func, ast.Name):
+            return
+
+        if node.func.id != "list":
+            return
+
+        if not node.args or not isinstance(node.args[0], ast.ListComp):
+            return
+        # pyrefactor: ignore
+        self.add_issue(
+            self._create_issue(
+                node,
+                severity=Severity.INFO,
+                rule_id="P004",
+                message="Redundant list() conversion of list comprehension",
+                suggestion="List comprehensions already return lists; remove list() wrapper",
+            )
+        )
+
+    def _check_len_usage(self, node: ast.Call) -> None:  # pyrefactor: ignore
+        """Check for len() calls and their usage patterns."""
+        if not isinstance(node.func, ast.Name):
+            return
+
+        if node.func.id != "len":
+            return
+
+        self._check_len_comparison(node)
+
+    def visit_Compare(self, node: ast.Compare) -> None:
+        """Check for inefficient comparisons."""
+        # Store parent reference for nested checks
+        self._set_parent_refs(node)
+        self.generic_visit(node)
+
+    def _set_parent_refs(self, node: ast.AST) -> None:
+        """Set parent references on all children of a node for upward traversal."""
+        for child in ast.walk(node):
+            setattr(child, "_parent", node)
+
+    def _check_len_comparison(self, len_call: ast.Call) -> None:
+        """Check for inefficient len() comparison patterns.
+
+        Detects patterns like:
+        - len(x) > 0 (should use truthiness)
+        - len(x) == 0 (should use 'not x')
+        """
+        len_parent: Optional[ast.AST] = getattr(len_call, "_parent", None)
+        if not isinstance(len_parent, ast.Compare):
+            return
+
+        if not len_parent.ops or not len_parent.comparators:
+            return
+
+        # Check if comparing with 0
+        has_zero_comp = any(
+            isinstance(comp, ast.Constant) and comp.value == 0
+            for comp in len_parent.comparators
+        )
+        if not has_zero_comp:
+            return
+
+        # Check for > or >= operators
+        if any(isinstance(op, (ast.Gt, ast.GtE)) for op in len_parent.ops):
+            self._add_len_issue(  # pyrefactor: ignore
+                len_call,
+                "P005",
+                "Use truthiness instead of len() > 0",
+                "Use 'if container:' instead of 'if len(container) > 0:'",
+            )
+        # Check for == or != operators
+        elif any(isinstance(op, (ast.Eq, ast.NotEq)) for op in len_parent.ops):
+            self._add_len_issue(  # pyrefactor: ignore
+                len_call,
+                "P006",
+                "Use truthiness instead of len() == 0",
+                "Use 'if not container:' instead of 'if len(container) == 0:'",
+            )
+
+    def _add_len_issue(
+        self, len_call: ast.Call, rule_id: str, message: str, suggestion: str
+    ) -> None:
+        """Add an issue for len() usage patterns."""
+        self.add_issue(
+            self._create_issue(
+                len_call,
+                severity=Severity.INFO,
+                rule_id=rule_id,
+                message=message,
+                suggestion=suggestion,
+            )
+        )
+
+    def _matches_type_hint(
+        self, node: ast.AST, type_name: str
+    ) -> bool:  # pyrefactor: ignore
+        """Check if a node likely matches a given type based on naming heuristics.
+
+        Args:
+            node: AST node to check
+            type_name: Type to check for ('string', 'list', or 'dict')
+
+        Returns:
+            True if the node name matches type hints, False otherwise
+        """
+        if not isinstance(node, ast.Name):
+            return False
+
+        name_lower = node.id.lower()
+        hints = self.TYPE_HINTS.get(type_name, [])
+
+        # Check if any hint appears in the variable name
+        return any(hint in name_lower for hint in hints) or (
+            type_name == "list" and name_lower.endswith("s")
+        )
+
+    def visit_ListComp(self, node: ast.ListComp) -> None:
+        """Check for list comprehension opportunities."""
+        self.generic_visit(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """Check for inefficient assignments."""
+        # Store parent references for nested analysis
+        self._set_parent_refs(node)
+        self.generic_visit(node)

pyrefactor/models.py

@@ -0,0 +1,98 @@
+"""Data models for PyRefactor."""
+
+import functools
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+@functools.total_ordering
+class Severity(Enum):
+    """Severity levels for detected issues."""
+
+    INFO = "info"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+    def __lt__(self, other: "Severity") -> bool:
+        """Compare severity levels."""
+        order = [Severity.INFO, Severity.LOW, Severity.MEDIUM, Severity.HIGH]
+        return order.index(self) < order.index(other)
+
+
+@dataclass
+class Issue:
+    """Represents a detected refactoring or optimization opportunity."""
+
+    file: str
+    line: int
+    column: int
+    severity: Severity
+    rule_id: str
+    message: str
+    suggestion: Optional[str] = None
+    code_snippet: Optional[str] = None
+    end_line: Optional[int] = None
+
+    def __post_init__(self) -> None:
+        """Validate issue data."""
+        if self.line < 1:
+            raise ValueError("Line number must be positive")
+        if self.column < 0:
+            raise ValueError("Column number must be non-negative")
+
+
+@dataclass
+class FileAnalysis:
+    """Results of analyzing a single file."""
+
+    file_path: str
+    issues: list[Issue] = field(default_factory=list)
+    parse_error: Optional[str] = None
+    lines_of_code: int = 0
+
+    def add_issue(self, issue: Issue) -> None:
+        """Add an issue to the analysis results."""
+        self.issues.append(issue)
+
+    def get_issues_by_severity(self, severity: Severity) -> list[Issue]:
+        """Get all issues matching a specific severity."""
+        return [issue for issue in self.issues if issue.severity == severity]
+
+    def has_errors(self) -> bool:
+        """Check if there are any high or medium severity issues."""
+        return any(
+            issue.severity in (Severity.HIGH, Severity.MEDIUM) for issue in self.issues
+        )
+
+
+@dataclass
+class AnalysisResult:
+    """Overall analysis results for multiple files."""
+
+    file_analyses: list[FileAnalysis] = field(default_factory=list)
+
+    def add_file_analysis(self, analysis: FileAnalysis) -> None:
+        """Add a file analysis to the results."""
+        self.file_analyses.append(analysis)
+
+    def get_all_issues(self) -> list[Issue]:
+        """Get all issues from all files."""
+        return [issue for analysis in self.file_analyses for issue in analysis.issues]
+
+    def get_issues_by_severity(self, severity: Severity) -> list[Issue]:
+        """Get all issues matching a specific severity."""
+        return [issue for issue in self.get_all_issues() if issue.severity == severity]
+
+    def total_issues(self) -> int:
+        """Get total count of issues."""
+        return len(self.get_all_issues())
+
+    def files_analyzed(self) -> int:
+        """Get count of files analyzed."""
+        return len(self.file_analyses)
+
+    def files_with_issues(self) -> int:
+        """Get count of files that have issues."""
+        return sum(1 for analysis in self.file_analyses if analysis.issues)

pyrefactor/reporter.py

@@ -0,0 +1,208 @@
+"""Console reporter for PyRefactor."""
+
+import io
+import sys
+from collections import defaultdict
+from typing import TextIO
+
+from colorama import Fore, Style, init
+
+from .models import AnalysisResult, Issue, Severity
+
+# Initialize colorama for cross-platform colored output
+init(autoreset=True)
+
+
+class ConsoleReporter:
+    """Reporter that outputs results to console."""
+
+    # Class-level constants for severity styling
+    SEVERITY_COLORS: dict[Severity, str] = {
+        Severity.HIGH: Fore.RED,
+        Severity.MEDIUM: Fore.YELLOW,
+        Severity.LOW: Fore.BLUE,
+        Severity.INFO: Fore.CYAN,
+    }
+
+    SEVERITY_ICONS: dict[Severity, str] = {
+        Severity.HIGH: "✗",
+        Severity.MEDIUM: "⚠",
+        Severity.LOW: "ℹ",
+        Severity.INFO: "→",
+    }
+
+    # ASCII fallback icons for terminals that don't support Unicode
+    ASCII_ICONS: dict[Severity, str] = {
+        Severity.HIGH: "X",
+        Severity.MEDIUM: "!",
+        Severity.LOW: "i",
+        Severity.INFO: ">",
+    }
+
+    def __init__(self, output: TextIO = sys.stdout) -> None:
+        """Initialize reporter with output stream."""
+        # Try to ensure UTF-8 encoding for Unicode symbols
+        if output is sys.stdout:
+            try:
+                # Reconfigure stdout to use UTF-8 encoding
+                if hasattr(sys.stdout, "reconfigure"):
+                    # Python 3.7+ TextIOWrapper.reconfigure method
+                    sys.stdout.reconfigure(encoding="utf-8")
+                    self.output = sys.stdout
+                    self.use_unicode = True
+                else:
+                    # Wrap stdout with UTF-8 text wrapper
+                    self.output = io.TextIOWrapper(
+                        sys.stdout.buffer,  # type: ignore[misc]
+                        encoding="utf-8",
+                        errors="replace",
+                    )
+                    self.use_unicode = True
+            except (AttributeError, OSError):
+                # Fall back to ASCII icons if UTF-8 is not available
+                self.output = output
+                self.use_unicode = False
+        else:
+            self.output = output
+            self.use_unicode = True
+
+    def report(self, result: AnalysisResult, group_by: str = "file") -> None:
+        """Generate and print report."""
+        if group_by == "file":
+            self._report_by_file(result)
+        elif group_by == "severity":
+            self._report_by_severity(result)
+        else:
+            self._report_by_file(result)
+
+        # Print summary
+        self._print_summary(result)
+
+    def _report_by_file(self, result: AnalysisResult) -> None:
+        """Report issues grouped by file."""
+        for analysis in result.file_analyses:
+            if analysis.parse_error:
+                self._print(f"\n{Fore.RED}✗ {analysis.file_path}{Style.RESET_ALL}")
+                self._print(f"  Parse error: {analysis.parse_error}")
+                continue
+
+            if not analysis.issues:
+                continue
+
+            # Print file header
+            self._print(f"\n{Fore.CYAN}{analysis.file_path}{Style.RESET_ALL}")
+
+            # Sort issues by line number
+            sorted_issues = sorted(
+                analysis.issues, key=lambda issue: issue.line  # type: ignore[misc]
+            )
+
+            # Print each issue
+            for issue in sorted_issues:
+                self._print_issue(issue)
+
+    def _report_by_severity(self, result: AnalysisResult) -> None:
+        """Report issues grouped by severity."""
+        issues_by_severity: dict[Severity, list[Issue]] = defaultdict(list)
+
+        for issue in result.get_all_issues():
+            issues_by_severity[issue.severity].append(issue)
+
+        # Print in order: HIGH, MEDIUM, LOW, INFO
+        for severity in [Severity.HIGH, Severity.MEDIUM, Severity.LOW, Severity.INFO]:
+            issues = issues_by_severity.get(severity, [])
+            if not issues:
+                continue
+
+            color = self._get_severity_color(severity)
+            self._print(
+                f"\n{color}{severity.value.upper()} Severity Issues{Style.RESET_ALL}"
+            )
+
+            # Sort by file and line
+            sorted_issues = sorted(
+                issues, key=lambda issue: (issue.file, issue.line)  # type: ignore[misc]
+            )
+
+            for issue in sorted_issues:
+                self._print_issue(issue, include_file=True)
+
+    def _print_issue(self, issue: Issue, include_file: bool = False) -> None:
+        """Print a single issue."""
+        # Severity indicator
+        severity_color = self._get_severity_color(issue.severity)
+        severity_icon = self._get_severity_icon(issue.severity)
+
+        # Location
+        location = f"{issue.line}:{issue.column}"
+        if include_file:
+            location = f"{issue.file}:{location}"
+
+        # Print main issue line
+        self._print(
+            f"  {severity_color}{severity_icon} [{issue.rule_id}] "
+            f"{location}{Style.RESET_ALL}"
+        )
+        self._print(f"    {issue.message}")
+
+        # Print suggestion if available
+        if issue.suggestion:
+            self._print(f"    {Fore.GREEN}→ {issue.suggestion}{Style.RESET_ALL}")
+
+        # Print code snippet if available
+        if issue.code_snippet:
+            self._print(
+                f"    {Fore.LIGHTBLACK_EX}{issue.code_snippet}{Style.RESET_ALL}"
+            )
+
+    def _print_summary(self, result: AnalysisResult) -> None:
+        """Print summary statistics."""
+        self._print(f"\n{Fore.YELLOW}{'=' * 70}{Style.RESET_ALL}")
+        self._print(f"{Fore.YELLOW}Summary{Style.RESET_ALL}")
+        self._print(f"{Fore.YELLOW}{'=' * 70}{Style.RESET_ALL}")
+
+        total_issues = result.total_issues()
+        files_analyzed = result.files_analyzed()
+        files_with_issues = result.files_with_issues()
+
+        self._print(f"\nFiles analyzed: {files_analyzed}")
+        self._print(f"Files with issues: {files_with_issues}")
+        self._print(f"Total issues: {total_issues}")
+
+        if total_issues > 0:
+            self._print("\nIssues by severity:")
+            for severity in [
+                Severity.HIGH,
+                Severity.MEDIUM,
+                Severity.LOW,
+                Severity.INFO,
+            ]:
+                count = len(result.get_issues_by_severity(severity))
+                if count > 0:
+                    color = self._get_severity_color(severity)
+                    self._print(
+                        f"  {color}{severity.value.upper()}: {count}{Style.RESET_ALL}"
+                    )
+
+        # Exit code indicator
+        if any(
+            issue.severity in (Severity.HIGH, Severity.MEDIUM)
+            for issue in result.get_all_issues()
+        ):
+            self._print(
+                f"\n{Fore.RED}⚠ High or medium severity issues found{Style.RESET_ALL}"
+            )
+
+    def _get_severity_color(self, severity: Severity) -> str:
+        """Get color for severity level."""
+        return self.SEVERITY_COLORS.get(severity, "")
+
+    def _get_severity_icon(self, severity: Severity) -> str:
+        """Get icon for severity level."""
+        if self.use_unicode:
+            return self.SEVERITY_ICONS.get(severity, "•")
+        return self.ASCII_ICONS.get(severity, "*")
+
+    def _print(self, message: str) -> None:
+        """Print a message to output."""
+        print(message, file=self.output)