pyrefactor 1.0.1__py3-none-any.whl

pyrefactor/__init__.py

@@ -0,0 +1,3 @@
+"""PyRefactor - A Python refactoring and optimization linter."""
+
+__version__ = "1.0.1"

pyrefactor/__main__.py

@@ -0,0 +1,231 @@
+"""CLI entry point for PyRefactor."""
+
+import argparse
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from . import __version__
+from .analyzer import Analyzer
+from .config import Config
+from .models import AnalysisResult, Severity
+from .reporter import ConsoleReporter
+
+# Configure logging
+logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Args:
+    """Type-safe argument namespace."""
+
+    paths: list[Path]
+    config: Optional[Path]
+    group_by: str
+    min_severity: str
+    jobs: int
+    verbose: bool
+    version: bool
+
+
+# Class-level constant for severity mapping to avoid recreation
+SEVERITY_MAP: dict[str, Severity] = {
+    "info": Severity.INFO,
+    "low": Severity.LOW,
+    "medium": Severity.MEDIUM,
+    "high": Severity.HIGH,
+}
+
+
+def _add_parser_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add all arguments to the parser."""
+    parser.add_argument(
+        "paths", nargs="*", type=Path, help="Python files or directories to analyze"
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        help="Path to configuration file (default: pyproject.toml)",
+    )
+    parser.add_argument(
+        "-g",
+        "--group-by",
+        choices=["file", "severity"],
+        default="file",
+        help="Group output by file or severity (default: file)",
+    )
+    parser.add_argument(
+        "--min-severity",
+        choices=["info", "low", "medium", "high"],
+        default="info",
+        help="Minimum severity level to report (default: info)",
+    )
+    parser.add_argument(
+        "-j", "--jobs", type=int, default=4, help="Number of parallel jobs (default: 4)"
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose logging"
+    )
+    parser.add_argument("--version", action="store_true", help="Show version and exit")
+
+
+def _create_argument_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        description="PyRefactor - A Python refactoring and optimization linter",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  pyrefactor myfile.py              Analyze a single file
+  pyrefactor src/                   Analyze all Python files in directory
+  pyrefactor file1.py file2.py      Analyze multiple files
+  pyrefactor --config custom.toml . Analyze with custom config
+
+Exit Codes:
+  0 - No issues or only INFO/LOW severity issues
+  1 - MEDIUM or HIGH severity issues found
+  2 - Error during analysis
+        """,
+    )
+    _add_parser_arguments(parser)
+    return parser
+
+
+def parse_arguments() -> Args:
+    """Parse command line arguments."""
+    parser = _create_argument_parser()
+    namespace = parser.parse_args()
+    # Convert to our typed class
+    # Note: argparse returns Any type for namespace attributes
+    return Args(
+        paths=namespace.paths,  # type: ignore[misc]
+        config=namespace.config,  # type: ignore[misc]
+        group_by=namespace.group_by,  # type: ignore[misc]
+        min_severity=namespace.min_severity,  # type: ignore[misc]
+        jobs=namespace.jobs,  # type: ignore[misc]
+        verbose=namespace.verbose,  # type: ignore[misc]
+        version=namespace.version,  # type: ignore[misc]
+    )
+
+
+def _handle_version(args: Args) -> Optional[int]:
+    """Handle version flag. Returns exit code if version flag is set, None otherwise."""
+    if args.version:
+        print(f"PyRefactor version {__version__}")
+        return 0
+    return None
+
+
+def _configure_logging(args: Args) -> None:
+    """Configure logging based on command line arguments."""
+    if args.verbose:
+        logging.getLogger().setLevel(logging.INFO)
+        logger.setLevel(logging.INFO)
+
+
+def _load_config(args: Args) -> Optional[Config]:
+    """Load configuration. Returns Config or None on error."""
+    try:
+        config = Config.load(args.config)
+        logger.info("Loaded configuration: %s", config)
+        return config
+    except Exception as e:
+        logger.error("Error loading configuration: %s", e)
+        return None
+
+
+def _validate_paths(args: Args) -> Optional[list[Path]]:
+    """Validate paths from arguments. Returns list of paths or None on error."""
+    paths: list[Path] = []
+    for path in args.paths:
+        if not path.exists():
+            logger.error("Path does not exist: %s", path)
+            return None
+        paths.append(path)
+    return paths
+
+
+def _analyze_files_safely(
+    analyzer: Analyzer, paths: list[Path]
+) -> Optional[AnalysisResult]:
+    """Analyze files and handle errors. Returns result or None on error."""
+    try:
+        logger.info("Analyzing %d path(s)...", len(paths))
+        return analyzer.analyze_files(paths)
+    except Exception as e:
+        logger.error("Error during analysis: %s", e)
+        return None
+
+
+def _get_min_severity(severity_str: str) -> Severity:
+    """Get Severity enum from string."""
+    return SEVERITY_MAP[severity_str]
+
+
+def _filter_by_severity(result: AnalysisResult, min_severity: Severity) -> None:
+    """Filter issues by minimum severity in-place."""
+    for file_analysis in result.file_analyses:
+        file_analysis.issues = [
+            issue for issue in file_analysis.issues if issue.severity >= min_severity
+        ]
+
+
+def _has_critical_issues(result: AnalysisResult) -> bool:
+    """Check if result has HIGH or MEDIUM severity issues."""
+    return any(
+        issue.severity in (Severity.HIGH, Severity.MEDIUM)
+        for issue in result.get_all_issues()
+    )
+
+
+def main() -> int:
+    """Main entry point."""
+    args = parse_arguments()
+
+    # Handle version
+    version_exit = _handle_version(args)
+    if version_exit is not None:
+        return version_exit
+
+    # Check if paths were provided
+    if not args.paths:
+        logger.error("No paths provided")
+        return 2
+
+    # Configure logging
+    _configure_logging(args)
+
+    # Load configuration
+    config = _load_config(args)
+    if config is None:
+        return 2
+
+    # Validate paths
+    paths = _validate_paths(args)
+    if paths is None:
+        return 2
+
+    # Create analyzer and analyze files
+    analyzer = Analyzer(config)
+    result = _analyze_files_safely(analyzer, paths)
+    if result is None:
+        return 2
+
+    # Filter by minimum severity
+    min_severity = _get_min_severity(args.min_severity)
+    _filter_by_severity(result, min_severity)
+
+    # Report results
+    reporter = ConsoleReporter()
+    reporter.report(result, group_by=args.group_by)
+
+    # Determine exit code
+    return 1 if _has_critical_issues(result) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyrefactor/analyzer.py

@@ -0,0 +1,185 @@
+"""Main analyzer orchestrator for PyRefactor."""
+
+import ast
+import concurrent.futures
+import logging
+from pathlib import Path
+
+from .ast_visitor import BaseDetector
+from .config import Config
+from .detectors import (
+    BooleanLogicDetector,
+    ComparisonsDetector,
+    ComplexityDetector,
+    ContextManagerDetector,
+    ControlFlowDetector,
+    DictOperationsDetector,
+    DuplicationDetector,
+    LoopsDetector,
+    PerformanceDetector,
+)
+from .models import AnalysisResult, FileAnalysis
+
+logger = logging.getLogger(__name__)
+
+
+class Analyzer:
+    """Main analyzer that orchestrates all detectors."""
+
+    def __init__(self, config: Config) -> None:
+        """Initialize analyzer with configuration."""
+        self.config = config
+
+    def _create_detectors(
+        self, file_path: str, source_lines: list[str]
+    ) -> list[BaseDetector]:
+        """Create all enabled detectors for a file.
+
+        Factory method to consolidate detector initialization and reduce duplication.
+        """
+        detectors: list[BaseDetector] = []
+
+        # Complexity detector (always enabled)
+        detectors.append(ComplexityDetector(self.config, file_path, source_lines))
+
+        # Conditionally enabled detectors
+        detector_configs = [
+            (self.config.performance.enabled, PerformanceDetector),
+            (self.config.boolean_logic.enabled, BooleanLogicDetector),
+            (self.config.loops.enabled, LoopsDetector),
+            (self.config.duplication.enabled, DuplicationDetector),
+            (self.config.context_manager.enabled, ContextManagerDetector),
+            (self.config.control_flow.enabled, ControlFlowDetector),
+            (self.config.dict_operations.enabled, DictOperationsDetector),
+            (self.config.comparisons.enabled, ComparisonsDetector),
+        ]
+
+        for enabled, detector_class in detector_configs:
+            if enabled:
+                detectors.append(detector_class(self.config, file_path, source_lines))
+
+        return detectors
+
+    def analyze_file(self, file_path: Path) -> FileAnalysis:
+        """Analyze a single Python file."""
+        analysis = FileAnalysis(file_path=str(file_path))
+
+        try:
+            # Read the file
+            source_code = file_path.read_text(encoding="utf-8")
+            source_lines = source_code.splitlines()
+            analysis.lines_of_code = len(source_lines)
+
+            # Parse the AST
+            try:
+                tree = ast.parse(source_code, filename=str(file_path))
+            except SyntaxError as e:
+                analysis.parse_error = f"Syntax error: {e}"
+                return analysis
+
+            # Create and run all enabled detectors
+            detectors = self._create_detectors(str(file_path), source_lines)
+            self._run_detectors(detectors, tree, analysis, file_path)
+
+        except Exception as e:
+            analysis.parse_error = f"Error analyzing file: {e}"
+            logger.error("Error analyzing %s: %s", file_path, e)
+
+        return analysis
+
+    def _run_detectors(
+        self,
+        detectors: list[BaseDetector],
+        tree: ast.Module,
+        analysis: FileAnalysis,
+        file_path: Path,
+    ) -> None:
+        """Run all detectors and collect issues."""
+        for detector in detectors:
+            try:
+                issues = detector.analyze(tree)
+                for issue in issues:
+                    analysis.add_issue(issue)
+            except Exception as e:
+                logger.error(
+                    "Error running %s on %s: %s",
+                    detector.get_detector_name(),
+                    file_path,
+                    e,
+                )
+
+    def analyze_directory(
+        self, directory: Path, max_workers: int = 4
+    ) -> AnalysisResult:
+        """Analyze all Python files in a directory."""
+        result = AnalysisResult()
+
+        # Find all Python files
+        python_files = list(directory.rglob("*.py"))
+
+        # Filter excluded patterns
+        python_files = self._filter_excluded_files(python_files)
+
+        if not python_files:
+            logger.warning("No Python files found in %s", directory)
+            return result
+
+        # Analyze files in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {
+                executor.submit(self.analyze_file, file_path): file_path
+                for file_path in python_files
+            }
+
+            for future in concurrent.futures.as_completed(future_to_file):
+                file_path = future_to_file[future]
+                try:
+                    analysis = future.result()
+                    result.add_file_analysis(analysis)
+                except Exception as e:
+                    logger.error("Error analyzing %s: %s", file_path, e)
+                    result.add_file_analysis(
+                        FileAnalysis(
+                            file_path=str(file_path),
+                            parse_error=f"Analysis failed: {e}",
+                        )
+                    )
+
+        return result
+
+    def analyze_files(self, file_paths: list[Path]) -> AnalysisResult:
+        """Analyze a list of Python files."""
+        result = AnalysisResult()
+
+        for file_path in file_paths:
+            self._process_path(file_path, result)
+
+        return result
+
+    def _process_path(self, file_path: Path, result: AnalysisResult) -> None:
+        """Process a single file or directory path.
+
+        Args:
+            file_path: Path to file or directory
+            result: AnalysisResult to add analyses to
+        """
+        if file_path.is_file():
+            analysis = self.analyze_file(file_path)
+            result.add_file_analysis(analysis)
+        elif file_path.is_dir():
+            dir_result = self.analyze_directory(file_path)
+            for analysis in dir_result.file_analyses:
+                result.add_file_analysis(analysis)
+
+    def _filter_excluded_files(self, files: list[Path]) -> list[Path]:
+        """Filter out files matching exclusion patterns."""
+        if not self.config.exclude_patterns:
+            return files
+
+        return [
+            file_path
+            for file_path in files
+            if not any(
+                pattern in str(file_path) for pattern in self.config.exclude_patterns
+            )
+        ]

pyrefactor/ast_visitor.py

@@ -0,0 +1,197 @@
+"""Base AST visitor framework for PyRefactor detectors."""
+
+import ast
+from abc import ABC, abstractmethod
+from typing import Union
+
+from .config import Config
+from .models import Issue
+
+
+class BaseDetector(ast.NodeVisitor, ABC):
+    """Base class for all detectors."""
+
+    def __init__(self, config: Config, file_path: str, source_lines: list[str]) -> None:
+        """Initialize detector with configuration and source context."""
+        self.config = config
+        self.file_path = file_path
+        self.source_lines = source_lines
+        self.issues: list[Issue] = []
+        self.current_function: Union[ast.FunctionDef, ast.AsyncFunctionDef, None] = None
+        self.nesting_level = 0
+
+    @abstractmethod
+    def get_detector_name(self) -> str:
+        """Return the name of this detector."""
+
+    def add_issue(self, issue: Issue) -> None:
+        """Add an issue to the detector's list."""
+        self.issues.append(issue)
+
+    def get_source_line(self, line: int) -> str:
+        """Get a specific source line (1-indexed)."""
+        if 1 <= line <= len(self.source_lines):
+            return self.source_lines[line - 1]
+        return ""
+
+    def get_source_snippet(self, start_line: int, end_line: int) -> str:
+        """Get a snippet of source code."""
+        if start_line < 1 or end_line > len(self.source_lines):
+            return ""
+        return "\n".join(self.source_lines[start_line - 1 : end_line])
+
+    def is_suppressed(self, node: ast.AST) -> bool:
+        """Check if a node has a suppression comment."""
+        if not hasattr(node, "lineno"):
+            return False
+
+        lineno: int = node.lineno
+        line = self.get_source_line(lineno)
+        # Check for suppression comments
+        if "# pyrefactor: ignore" in line or "# noqa" in line:
+            return True
+
+        # Check previous line for suppression
+        if lineno > 1:
+            prev_line = self.get_source_line(lineno - 1)
+            if "# pyrefactor: ignore" in prev_line or "# noqa" in prev_line:
+                return True
+
+        return False
+
+    def analyze(self, tree: ast.AST) -> list[Issue]:
+        """Run the detector on an AST and return issues found."""
+        self.visit(tree)
+        return self.issues
+
+
+def calculate_cyclomatic_complexity(
+    node: Union[ast.FunctionDef, ast.AsyncFunctionDef],
+) -> int:
+    """Calculate cyclomatic complexity of a function."""
+
+    class ComplexityVisitor(ast.NodeVisitor):
+        """Visitor to count decision points."""
+
+        def __init__(self) -> None:
+            self.complexity = 1  # Base complexity
+
+        def visit_If(self, node: ast.If) -> None:
+            """Count if statements."""
+            self._increment_and_visit(node)
+
+        def visit_For(self, node: ast.For) -> None:
+            """Count for loops."""
+            self._increment_and_visit(node)
+
+        def visit_While(self, node: ast.While) -> None:
+            """Count while loops."""
+            self._increment_and_visit(node)
+
+        def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+            """Count except handlers."""
+            self._increment_and_visit(node)
+
+        def visit_With(self, node: ast.With) -> None:
+            """Count with statements."""
+            self._increment_and_visit(node)
+
+        def visit_Assert(self, node: ast.Assert) -> None:
+            """Count assertions."""
+            self._increment_and_visit(node)
+
+        def visit_BoolOp(self, node: ast.BoolOp) -> None:
+            """Count boolean operations (and/or)."""
+            self.complexity += len(node.values) - 1
+            self.generic_visit(node)
+
+        def _increment_and_visit(self, node: ast.AST) -> None:
+            """Increment complexity and continue visiting."""
+            self.complexity += 1
+            self.generic_visit(node)
+
+    visitor = ComplexityVisitor()
+    visitor.visit(node)
+    return visitor.complexity
+
+
+def count_nesting_depth(node: ast.AST) -> int:
+    """Calculate maximum nesting depth in a node."""
+
+    class NestingVisitor(ast.NodeVisitor):
+        """Visitor to track nesting depth."""
+
+        def __init__(self) -> None:
+            self.current_depth = 0
+            self.max_depth = 0
+
+        def visit_If(self, node: ast.If) -> None:
+            """Track if nesting."""
+            self._visit_nested(node)
+
+        def visit_For(self, node: ast.For) -> None:
+            """Track for loop nesting."""
+            self._visit_nested(node)
+
+        def visit_While(self, node: ast.While) -> None:
+            """Track while loop nesting."""
+            self._visit_nested(node)
+
+        def visit_With(self, node: ast.With) -> None:
+            """Track with statement nesting."""
+            self._visit_nested(node)
+
+        def visit_Try(self, node: ast.Try) -> None:
+            """Track try block nesting."""
+            self._visit_nested(node)
+
+        def _visit_nested(self, node: ast.AST) -> None:
+            """Visit a nested structure."""
+            self.current_depth += 1
+            self.max_depth = max(self.max_depth, self.current_depth)
+            self.generic_visit(node)
+            self.current_depth -= 1
+
+    visitor = NestingVisitor()
+    visitor.visit(node)
+    return visitor.max_depth
+
+
+def count_branches(node: Union[ast.FunctionDef, ast.AsyncFunctionDef]) -> int:
+    """Count the number of branches in a function."""
+
+    class BranchVisitor(ast.NodeVisitor):
+        """Visitor to count branches."""
+
+        def __init__(self) -> None:
+            self.branches = 0
+
+        def visit_If(self, node: ast.If) -> None:
+            """Count if/elif branches."""
+            self.branches += 1
+            if node.orelse:
+                # Check if else contains another if (elif)
+                if len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
+                    pass  # Will be counted when we visit that node
+                else:
+                    self.branches += 1  # else branch
+            self.generic_visit(node)
+
+        def visit_For(self, node: ast.For) -> None:
+            """Count for loops as branches."""
+            self.branches += 1
+            self.generic_visit(node)
+
+        def visit_While(self, node: ast.While) -> None:
+            """Count while loops as branches."""
+            self.branches += 1
+            self.generic_visit(node)
+
+        def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+            """Count exception handlers."""
+            self.branches += 1
+            self.generic_visit(node)
+
+    visitor = BranchVisitor()
+    visitor.visit(node)
+    return visitor.branches