coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/handlers/compilation.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+智能编译失败处理器
+支持渐进式删除策略和依赖分析
+"""
+
+import os
+import re
+import shutil
+from typing import List, Tuple, Optional, Dict, Set
+from pathlib import Path
+from dataclasses import dataclass, field
+from enum import Enum
+
+from coverage_tool.utils import FileBackupManager, DependencyGraph, Logger, parse_error_locations, safe_delete_file
+
+
+class FilePriority(Enum):
+    """文件优先级"""
+    LOW = 1      # 可以安全删除的文件（如测试文件、示例文件）
+    MEDIUM = 2   # 普通源文件
+    HIGH = 3     # 核心文件（如main文件、配置文件）
+    CRITICAL = 4 # 绝对不能删除的文件
+
+
+@dataclass
+class FileInfo:
+    """文件信息"""
+    path: str
+    priority: FilePriority
+    error_count: int = 0
+    is_test_file: bool = False
+    is_source_file: bool = False
+    dependents: List[str] = field(default_factory=list)
+
+
+class SmartCompilationHandler:
+    """智能编译失败处理器"""
+    
+    def __init__(self, target_dir: str, logger: Optional[Logger] = None):
+        self.target_dir = target_dir
+        self.logger = logger or Logger()
+        self.backup_manager = FileBackupManager()
+        self.dependency_graph = DependencyGraph()
+        self.deleted_files: List[str] = []
+        self.compilation_history: List[Dict] = []
+        
+        # 文件优先级模式
+        self.priority_patterns = {
+            FilePriority.LOW: [
+                r'.*test.*\.(py|java|go|c|cpp|h|hpp)$',
+                r'.*example.*\.(py|java|go|c|cpp)$',
+                r'.*demo.*\.(py|java|go|c|cpp)$',
+                r'.*mock.*\.(py|java|go|c|cpp)$',
+                r'.*stub.*\.(py|java|go|c|cpp)$',
+            ],
+            FilePriority.HIGH: [
+                r'^main\.(py|java|go|c|cpp)$',
+                r'^index\.(py|java|go|c|cpp)$',
+                r'^app\.(py|java|go|c|cpp)$',
+                r'^setup\.py$',
+                r'^[Rr]eadme\.md$',
+                r'^go\.mod$',
+                r'^pom\.xml$',
+                r'^build\.gradle$',
+                r'^Makefile$',
+                r'^CMakeLists\.txt$',
+            ],
+            FilePriority.CRITICAL: [
+                r'.*\.git.*',
+                r'.*\.svn.*',
+            ]
+        }
+    
+    def analyze_compilation_errors(self, errors: List[str]) -> List[FileInfo]:
+        """分析编译错误，提取问题文件"""
+        error_locations = parse_error_locations(errors, self.target_dir)
+        
+        file_infos = []
+        for file_path, line_nums in error_locations.items():
+            if os.path.exists(file_path):
+                info = FileInfo(
+                    path=file_path,
+                    priority=self._determine_priority(file_path),
+                    error_count=len(line_nums),
+                    is_test_file=self._is_test_file(file_path),
+                    is_source_file=self._is_source_file(file_path)
+                )
+                file_infos.append(info)
+        
+        # 按优先级和错误数量排序（优先级低的先删除）
+        file_infos.sort(key=lambda x: (x.priority.value, -x.error_count))
+        
+        return file_infos
+    
+    def _determine_priority(self, file_path: str) -> FilePriority:
+        """确定文件优先级"""
+        file_name = os.path.basename(file_path)
+        
+        # 检查CRITICAL模式
+        for pattern in self.priority_patterns[FilePriority.CRITICAL]:
+            if re.match(pattern, file_name, re.IGNORECASE):
+                return FilePriority.CRITICAL
+        
+        # 检查HIGH模式
+        for pattern in self.priority_patterns[FilePriority.HIGH]:
+            if re.match(pattern, file_name, re.IGNORECASE):
+                return FilePriority.HIGH
+        
+        # 检查LOW模式
+        for pattern in self.priority_patterns[FilePriority.LOW]:
+            if re.match(pattern, file_name, re.IGNORECASE):
+                return FilePriority.LOW
+        
+        return FilePriority.MEDIUM
+    
+    def _is_test_file(self, file_path: str) -> bool:
+        """检查是否是测试文件"""
+        test_patterns = [
+            r'.*test.*\.(py|java|go|c|cpp)$',
+            r'.*_test\.(py|java|go|c|cpp)$',
+            r'test_.*\.py$',
+            r'.*Test\.java$',
+        ]
+        file_name = os.path.basename(file_path)
+        for pattern in test_patterns:
+            if re.match(pattern, file_name, re.IGNORECASE):
+                return True
+        return False
+    
+    def _is_source_file(self, file_path: str) -> bool:
+        """检查是否是源文件"""
+        source_extensions = ['.py', '.java', '.go', '.c', '.cpp', '.h', '.hpp']
+        ext = os.path.splitext(file_path)[1].lower()
+        return ext in source_extensions
+    
+    def handle_compilation_failure(
+        self, 
+        errors: List[str], 
+        compile_func,
+        max_iterations: int = 10
+    ) -> Tuple[bool, List[str], List[str]]:
+        """
+        处理编译失败，使用渐进式删除策略
+        
+        Args:
+            errors: 编译错误列表
+            compile_func: 编译函数，接收target_dir，返回(success, errors)
+            max_iterations: 最大尝试次数
+            
+        Returns:
+            (编译是否成功, 被删除的文件列表, 剩余的编译错误)
+        """
+        self.logger.info(f"开始处理编译失败，共 {len(errors)} 个错误")
+        
+        iteration = 0
+        current_errors = errors.copy()
+        
+        while iteration < max_iterations and current_errors:
+            iteration += 1
+            self.logger.info(f"编译修复迭代 {iteration}/{max_iterations}")
+            
+            # 分析错误
+            file_infos = self.analyze_compilation_errors(current_errors)
+            
+            if not file_infos:
+                self.logger.warning("无法从错误信息中识别问题文件")
+                break
+            
+            # 过滤掉不能删除的文件
+            deletable_files = [
+                info for info in file_infos 
+                if info.priority not in [FilePriority.CRITICAL, FilePriority.HIGH]
+            ]
+            
+            if not deletable_files:
+                self.logger.warning("没有可安全删除的文件")
+                break
+            
+            # 选择要删除的文件（每次最多删除3个，避免过度删除）
+            files_to_delete = deletable_files[:3]
+            
+            # 检查依赖关系
+            for file_info in files_to_delete:
+                impacted = self.dependency_graph.get_impact_files(file_info.path)
+                if impacted:
+                    self.logger.warning(
+                        f"删除 {file_info.path} 会影响 {len(impacted)} 个文件"
+                    )
+            
+            # 备份并删除文件
+            deleted_in_iteration = []
+            for file_info in files_to_delete:
+                if safe_delete_file(file_info.path, self.backup_manager):
+                    deleted_in_iteration.append(file_info.path)
+                    self.deleted_files.append(file_info.path)
+                    self.logger.info(f"已删除文件: {file_info.path}")
+            
+            if not deleted_in_iteration:
+                self.logger.warning("本轮未能删除任何文件")
+                break
+            
+            # 记录编译历史
+            self.compilation_history.append({
+                'iteration': iteration,
+                'deleted_files': deleted_in_iteration,
+                'error_count_before': len(current_errors)
+            })
+            
+            # 尝试重新编译
+            success, new_errors = compile_func(self.target_dir)
+            
+            if success:
+                self.logger.info(f"编译成功！共进行了 {iteration} 轮修复")
+                return True, self.deleted_files, []
+            
+            # 检查错误是否减少
+            if len(new_errors) >= len(current_errors):
+                self.logger.warning(
+                    f"错误数量未减少 ({len(current_errors)} -> {len(new_errors)})，"
+                    "可能需要更激进的删除策略"
+                )
+            
+            current_errors = new_errors
+        
+        # 达到最大迭代次数仍未成功
+        self.logger.error(f"编译修复失败，已达到最大迭代次数 {max_iterations}")
+        return False, self.deleted_files, current_errors
+    
+    def restore_deleted_files(self) -> List[str]:
+        """恢复所有已删除的文件"""
+        restored = []
+        for file_path in self.deleted_files:
+            if self.backup_manager.restore_file(file_path):
+                restored.append(file_path)
+                self.logger.info(f"已恢复文件: {file_path}")
+        self.deleted_files.clear()
+        return restored
+    
+    def get_deleted_files(self) -> List[str]:
+        """获取已删除的文件列表"""
+        return self.deleted_files.copy()
+    
+    def get_compilation_history(self) -> List[Dict]:
+        """获取编译历史记录"""
+        return self.compilation_history.copy()
+    
+    def cleanup(self):
+        """清理资源"""
+        self.backup_manager.cleanup()
+
+
+class CompilationErrorParser:
+    """编译错误解析器"""
+    
+    # 各种语言的编译错误模式
+    ERROR_PATTERNS = {
+        'python': [
+            (r'File "([^"]+\.py)", line (\d+)', 'file_and_line'),
+            (r'SyntaxError.*in ([^\s]+\.py)', 'syntax_error'),
+            (r'ImportError.*from ([^\s]+\.py)', 'import_error'),
+        ],
+        'java': [
+            (r'([^\s]+\.java):(\d+):', 'file_and_line'),
+            (r'error: cannot find symbol\s+Location: ([^\s]+\.java)', 'symbol_error'),
+            (r'error: package ([^\s]+) does not exist', 'package_error'),
+        ],
+        'go': [
+            (r'# ([^\s]+)', 'package_error'),
+            (r'([^\s]+\.go):(\d+):(\d+):', 'file_and_line'),
+            (r'([^\s]+\.go):(\d+):', 'file_and_line'),
+            (r'undefined:\s+(\w+)', 'undefined_error'),
+        ],
+        'c': [
+            (r'([^\s]+\.(c|h)):(\d+):(\d+):', 'file_and_line'),
+            (r'([^\s]+\.(c|h)):(\d+):', 'file_and_line'),
+            (r'undefined reference to', 'link_error'),
+        ],
+        'cpp': [
+            (r'([^\s]+\.(cpp|hpp|cc|hh)):(\d+):(\d+):', 'file_and_line'),
+            (r'([^\s]+\.(cpp|hpp|cc|hh)):(\d+):', 'file_and_line'),
+            (r'undefined reference to', 'link_error'),
+        ]
+    }
+    
+    @staticmethod
+    def parse_errors(errors: List[str], language: str, project_dir: str) -> Dict[str, List[Dict]]:
+        """
+        解析编译错误
+        
+        Returns:
+            按文件分类的错误信息
+        """
+        patterns = CompilationErrorParser.ERROR_PATTERNS.get(language, [])
+        file_errors: Dict[str, List[Dict]] = {}
+        
+        for error in errors:
+            for pattern, error_type in patterns:
+                matches = re.findall(pattern, error)
+                for match in matches:
+                    if isinstance(match, tuple):
+                        file_path = match[0]
+                        line_num = int(match[1]) if len(match) > 1 and match[1].isdigit() else 0
+                    else:
+                        file_path = match
+                        line_num = 0
+                    
+                    # 规范化路径
+                    if not os.path.isabs(file_path):
+                        file_path = os.path.join(project_dir, file_path)
+                    file_path = os.path.normpath(file_path)
+                    
+                    if file_path not in file_errors:
+                        file_errors[file_path] = []
+                    
+                    file_errors[file_path].append({
+                        'line': line_num,
+                        'type': error_type,
+                        'message': error
+                    })
+        
+        return file_errors

coverage_tool/handlers/env_checker.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+环境检查器
+检查各语言编译和测试环境是否满足要求
+支持根据项目配置文件智能分析依赖
+"""
+
+import subprocess
+import shutil
+import os
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from enum import Enum
+from pathlib import Path
+
+class EnvironmentStatus(Enum):
+    OK = "ok"
+    MISSING = "missing"
+    WARNING = "warning"
+    OPTIONAL = "optional"
+
+@dataclass
+class EnvironmentCheck:
+    """环境检查项"""
+    name: str
+    status: EnvironmentStatus
+    version: Optional[str] = None
+    message: str = ""
+    suggestion: str = ""
+    required_by_project: bool = False
+
+@dataclass
+class EnvironmentReport:
+    """环境检查报告"""
+    language: str
+    checks: List[EnvironmentCheck] = field(default_factory=list)
+    all_passed: bool = True
+    critical_missing: List[str] = field(default_factory=list)
+    installation_suggestions: List[str] = field(default_factory=list)
+    project_config_detected: List[str] = field(default_factory=list)
+
+    def add_check(self, check: EnvironmentCheck):
+        self.checks.append(check)
+        if check.status == EnvironmentStatus.MISSING and check.required_by_project:
+            self.all_passed = False
+            self.critical_missing.append(check.name)
+
+class EnvironmentChecker:
+    """环境检查器"""
+
+    def __init__(self):
+        self.check_results: Dict[str, EnvironmentReport] = {}
+
+    def check_language_environment(self, language: str, project_dir: str = None) -> EnvironmentReport:
+        """检查特定语言的环境"""
+        report = EnvironmentReport(language=language)
+
+        # 分析项目依赖
+        if project_dir and os.path.exists(project_dir):
+            self._analyze_project_dependencies(report, language, project_dir)
+
+        if language == "python":
+            self._check_python_env(report)
+        elif language == "java":
+            self._check_java_env(report)
+        elif language == "go":
+            self._check_go_env(report)
+        elif language in ["c", "cpp"]:
+            self._check_c_cpp_env(report)
+
+        return report
+
+    def _analyze_project_dependencies(self, report: EnvironmentReport, language: str, project_dir: str):
+        """分析项目配置文件"""
+        from coverage_tool.analyzers import DependencyAnalyzer
+
+        analyzer = DependencyAnalyzer(project_dir)
+        analysis = analyzer.analyze(language)
+
+        if analysis is None:
+            return
+
+        # 记录检测到的配置文件
+        if analysis.build_system:
+            report.project_config_detected.append(f"构建系统: {analysis.build_system}")
+        if analysis.test_framework:
+            report.project_config_detected.append(f"测试框架: {analysis.test_framework}")
+        if analysis.warnings:
+            for warning in analysis.warnings:
+                report.project_config_detected.append(f"⚠ {warning}")
+
+        # 检查项目依赖是否已安装
+        for dep in analysis.dependencies:
+            if dep.required or dep.installed:
+                check = EnvironmentCheck(
+                    name=dep.name,
+                    status=EnvironmentStatus.OK if dep.installed else EnvironmentStatus.MISSING,
+                    version=dep.installed_version or dep.version or "",
+                    message=f"{'已安装' if dep.installed else '未安装'}",
+                    required_by_project=dep.required,
+                    suggestion=self._get_suggestion(dep.name, language)
+                )
+                report.add_check(check)
+
+    def _get_suggestion(self, dep_name: str, language: str) -> str:
+        """获取安装建议"""
+        suggestions = {
+            'pytest': 'pip install pytest',
+            'coverage': 'pip install coverage',
+            'tox': 'pip install tox',
+            'unittest': 'Python标准库，无需安装',
+            'maven': 'apt install maven (Linux) / brew install maven (macOS)',
+            'gradle': 'https://gradle.org/install/',
+            'java': 'https://adoptium.net/ 或 https://www.oracle.com/java/',
+            'go': 'https://go.dev/dl/',
+            'gcc': 'apt install gcc (Linux) / brew install gcc (macOS)',
+            'g++': 'apt install g++ (Linux) / brew install gcc (macOS)',
+            'make': 'apt install make (Linux) / brew install make (macOS)',
+            'cmake': 'https://cmake.org/download/',
+            'gcov': '随GCC安装',
+            'lcov': 'apt install lcov (Linux)',
+            'googletest': 'apt install libgtest-dev cmake',
+        }
+        return suggestions.get(dep_name, f'请安装 {dep_name}')
+
+    def _run_command(self, cmd: str) -> Tuple[bool, str, str]:
+        """运行命令检查"""
+        try:
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            return result.returncode == 0, result.stdout, result.stderr
+        except subprocess.TimeoutExpired:
+            return False, "", "命令执行超时"
+        except Exception as e:
+            return False, "", str(e)
+
+    def _check_python_env(self, report: EnvironmentReport):
+        """检查Python环境"""
+        check = EnvironmentCheck(
+            name="Python",
+            status=EnvironmentStatus.OK,
+            version="",
+            message="Python 环境正常",
+            required_by_project=True
+        )
+        success, stdout, _ = self._run_command("python3 --version")
+        if success:
+            check.version = stdout.strip()
+            check.message = f"Python 版本: {check.version}"
+        else:
+            check.status = EnvironmentStatus.MISSING
+            check.message = "未找到 Python"
+            check.suggestion = "请安装 Python 3.7+: https://www.python.org/downloads/"
+        report.add_check(check)
+
+        # 检查pytest
+        success, stdout, _ = self._run_command("python3 -m pytest --version")
+        check = EnvironmentCheck(
+            name="pytest",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.WARNING,
+            message="pytest 未安装" if not success else f"pytest 版本: {stdout.strip().split(chr(10))[0] if stdout else '未知'}",
+            suggestion="pip install pytest" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+        # 检查coverage
+        success, stdout, _ = self._run_command("python3 -m coverage --version")
+        check = EnvironmentCheck(
+            name="coverage.py",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.WARNING,
+            message="coverage.py 未安装" if not success else f"coverage.py 已安装",
+            suggestion="pip install coverage" if not success else "",
+            required_by_project=False
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+    def _check_java_env(self, report: EnvironmentReport):
+        """检查Java环境"""
+        success, stdout, stderr = self._run_command("java -version 2>&1")
+        check = EnvironmentCheck(
+            name="Java JDK",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.MISSING,
+            version="",
+            message="未找到 Java JDK" if not success else f"Java 版本: {(stdout or stderr).strip().split(chr(10))[0] if (stdout or stderr) else '未知'}",
+            suggestion="请安装 JDK 8+: https://adoptium.net/" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = (stdout or stderr).strip().split('\n')[0]
+        report.add_check(check)
+
+        success, stdout, _ = self._run_command("mvn -version")
+        check = EnvironmentCheck(
+            name="Maven",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.WARNING,
+            message="Maven 未安装" if not success else f"Maven 版本: {stdout.strip().split(chr(10))[0] if stdout else '未知'}",
+            suggestion="apt install maven / brew install maven" if not success else "",
+            required_by_project=False
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+    def _check_go_env(self, report: EnvironmentReport):
+        """检查Go环境"""
+        success, stdout, _ = self._run_command("go version")
+        check = EnvironmentCheck(
+            name="Go SDK",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.MISSING,
+            version="",
+            message="未找到 Go SDK" if not success else f"Go 版本: {stdout.strip() if stdout else '未知'}",
+            suggestion="请安装 Go 1.16+: https://go.dev/dl/" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = stdout.strip()
+        report.add_check(check)
+
+    def _check_c_cpp_env(self, report: EnvironmentReport):
+        """检查C/C++环境"""
+        success, stdout, _ = self._run_command("gcc --version")
+        check = EnvironmentCheck(
+            name="GCC",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.MISSING,
+            version="",
+            message="GCC 未安装" if not success else f"GCC 版本: {stdout.strip().split(chr(10))[0] if stdout else '未知'}",
+            suggestion="apt install gcc (Linux) / brew install gcc (macOS)" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+        success, stdout, _ = self._run_command("g++ --version")
+        check = EnvironmentCheck(
+            name="G++",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.MISSING,
+            version="",
+            message="G++ 未安装" if not success else f"G++ 版本: {stdout.strip().split(chr(10))[0] if stdout else '未知'}",
+            suggestion="apt install g++ (Linux) / brew install gcc (macOS)" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+        success, stdout, _ = self._run_command("make --version")
+        check = EnvironmentCheck(
+            name="Make",
+            status=EnvironmentStatus.OK if success else EnvironmentStatus.MISSING,
+            version="",
+            message="Make 未安装" if not success else f"Make 版本: {stdout.strip().split(chr(10))[0] if stdout else '未知'}",
+            suggestion="apt install make (Linux) / brew install make (macOS)" if not success else "",
+            required_by_project=True
+        )
+        if success:
+            check.version = stdout.strip().split('\n')[0]
+        report.add_check(check)
+
+    def print_report(self, report: EnvironmentReport):
+        """打印环境检查报告"""
+        print(f"\n{'='*60}")
+        print(f"环境检查报告: {report.language}")
+        print('='*60)
+
+        # 显示检测到的项目配置
+        if report.project_config_detected:
+            print("\n📁 检测到的项目配置:")
+            for config in report.project_config_detected:
+                print(f"   • {config}")
+
+        for check in report.checks:
+            if check.status == EnvironmentStatus.OK:
+                status_icon = "✓"
+            elif check.status == EnvironmentStatus.WARNING:
+                status_icon = "⚠"
+            elif check.status == EnvironmentStatus.MISSING:
+                status_icon = "✗"
+            else:
+                status_icon = "○"
+
+            print(f"\n{status_icon} {check.name}")
+            if check.version:
+                print(f"   版本: {check.version}")
+            print(f"   {check.message}")
+            if check.suggestion:
+                print(f"   安装: {check.suggestion}")
+
+        print(f"\n{'='*60}")
+        if report.all_passed:
+            print("✓ 环境检查通过")
+        else:
+            print("✗ 存在缺失的关键依赖，请先安装")
+            print(f"缺失项: {', '.join(report.critical_missing)}")
+        print('='*60)
+
+    def check_all_and_print(self, language: str, project_dir: str = None):
+        """检查并打印所有环境信息"""
+        report = self.check_language_environment(language, project_dir)
+        self.print_report(report)
+        return report