coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/test_removers/java_remover.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Java测试删除器
+使用正则表达式解析Java测试文件
+"""
+
+import re
+from typing import List, Optional
+from pathlib import Path
+
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction
+from coverage_tool.parsers import TestCase
+
+
+class JavaSmartTestRemover(BaseSmartTestRemover):
+    """Java智能测试删除器"""
+    
+    # 预编译正则表达式提高性能
+    TEST_METHOD_PATTERN = re.compile(
+        r'(@Test(?:\([^)]*\))?\s*)?'  # @Test 注解（可选）
+        r'(?:@\w+\s*)*'               # 其他注解
+        r'(?:public\s+)?'             # 访问修饰符
+        r'(?:void|static)?\s+'        # 返回类型
+        r'(\w+)\s*'                   # 方法名
+        r'\([^)]*\)\s*'              # 参数列表
+        r'\{',                        # 方法开始
+        re.MULTILINE | re.DOTALL
+    )
+    
+    def _is_build_failure(self, test_name: str) -> bool:
+        """检查是否是Java构建失败的特殊测试名称"""
+        build_failure_patterns = [
+            '[build failed]',
+            '[compilation failed]',
+            'Compilation failure',
+            'cannot find symbol',
+            'package does not exist',
+            'class not found',
+        ]
+        return any(pattern in test_name for pattern in build_failure_patterns)
+    
+    def remove_all_tests_in_package(self, package_path: str) -> tuple:
+        """
+        删除指定Java包内的所有测试文件
+        用于处理包级编译错误
+        """
+        deleted_count = 0
+        deleted_files = []
+        
+        # Java包路径格式: com.example.test
+        package_parts = package_path.split('.')
+        
+        if len(package_parts) > 0:
+            # 将包路径转换为目录路径
+            for i in range(len(package_parts)):
+                subdir = '/'.join(package_parts[i:])
+                
+                # 搜索可能的目录结构
+                search_paths = [
+                    Path(self.project_dir) / subdir,
+                    Path(self.project_dir) / 'src' / 'test' / 'java' / subdir,
+                    Path(self.project_dir) / 'test' / subdir,
+                    Path(self.project_dir) / 'tests' / subdir,
+                ]
+                
+                for dir_path in search_paths:
+                    if dir_path.exists() and dir_path.is_dir():
+                        # 查找该目录下的所有测试文件
+                        test_files = list(dir_path.glob("*Test.java")) + list(dir_path.glob("Test*.java"))
+                        
+                        if test_files:
+                            self.logger.info(f"[编译错误] 在包 {package_path} 目录 {dir_path} 发现 {len(test_files)} 个测试文件")
+                            
+                            for test_file in test_files:
+                                try:
+                                    # 备份文件
+                                    self.backup_manager.backup_file(str(test_file))
+                                    # 删除文件
+                                    test_file.unlink()
+                                    deleted_count += 1
+                                    deleted_files.append(str(test_file))
+                                    self.logger.info(f"[编译错误] ✓ 已删除测试文件: {test_file}")
+                                except Exception as e:
+                                    self.logger.error(f"[编译错误] 删除文件失败: {test_file}: {e}")
+                            
+                            return deleted_count, deleted_files
+        
+        # 如果没找到，尝试递归搜索
+        for search_pattern in ["**/*Test.java", "**/Test*.java"]:
+            for test_file in Path(self.project_dir).rglob(search_pattern):
+                try:
+                    with open(test_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    # 检查文件是否包含该包的导入或引用
+                    if f"package {package_path}" in content or f"import {package_path}" in content:
+                        self.backup_manager.backup_file(str(test_file))
+                        test_file.unlink()
+                        deleted_count += 1
+                        deleted_files.append(str(test_file))
+                        self.logger.info(f"[编译错误] ✓ 已删除测试文件: {test_file}")
+                except:
+                    continue
+        
+        return deleted_count, deleted_files
+    
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """查找Java测试方法"""
+        test_methods = []
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            for match in self.TEST_METHOD_PATTERN.finditer(content):
+                has_test_annotation = match.group(1) is not None
+                method_name = match.group(2)
+                
+                # 如果方法名以 test 开头或有@Test注解
+                if has_test_annotation or method_name.startswith('test'):
+                    # 计算行号
+                    start_pos = match.start()
+                    line_num = content[:start_pos].count('\n') + 1
+                    
+                    # 找到方法结束位置
+                    brace_count = 0
+                    end_pos = match.end()
+                    for i, char in enumerate(content[match.end():]):
+                        if char == '{':
+                            brace_count += 1
+                        elif char == '}':
+                            brace_count -= 1
+                            if brace_count == 0:
+                                end_pos = match.end() + i + 1
+                                break
+                    
+                    end_line = content[:end_pos].count('\n') + 1
+                    
+                    test_func = TestFunction(
+                        name=method_name,
+                        file_path=file_path,
+                        start_line=line_num,
+                        end_line=end_line,
+                        decorators=['Test'] if has_test_annotation else []
+                    )
+                    test_methods.append(test_func)
+        
+        except Exception as e:
+            self.logger.error(f"解析Java文件失败 {file_path}: {e}")
+        
+        return test_methods
+    
+    def _get_deletion_range(self, test_func: TestFunction, lines: List[str]) -> tuple:
+        """
+        获取Java测试方法的删除范围
+        考虑注解
+        """
+        start_idx = self._adjust_start_for_decorators(
+            test_func, lines, comment_prefixes=['//']
+        )
+        end_idx = test_func.end_line
+        return start_idx, end_idx
+    
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """查找Java测试文件"""
+        classname = test_case.classname
+        test_name = test_case.name
+        
+        # 处理特殊的构建失败错误
+        if self._is_build_failure(test_name):
+            self.logger.info(f"[编译错误] 检测到Java编译失败: {test_name}")
+            # 如果是编译失败，classname通常包含包路径
+            # 尝试从包名推断目录
+            package_parts = classname.split('.')
+            if len(package_parts) > 1:
+                # 尝试不同的包目录组合
+                for i in range(len(package_parts)):
+                    subdir = '/'.join(package_parts[i:])
+                    search_paths = [
+                        Path(self.project_dir) / subdir,
+                        Path(self.project_dir) / 'src' / 'test' / 'java' / subdir,
+                        Path(self.project_dir) / 'test' / subdir,
+                    ]
+                    for dir_path in search_paths:
+                        if dir_path.exists() and dir_path.is_dir():
+                            # 查找该目录下的测试文件
+                            for test_file in dir_path.glob("*Test.java"):
+                                if test_file.exists():
+                                    self.logger.info(f"[编译错误] 找到包 {classname} 的测试文件: {test_file}")
+                                    return str(test_file)
+        
+        parts = classname.split('.')
+        
+        if len(parts) > 1:
+            # 完整的包路径
+            package_path = '/'.join(parts[:-1])
+            class_name = parts[-1]
+            patterns = [
+                f"{package_path}/{class_name}Test.java",
+                f"{package_path}/Test{class_name}.java",
+                f"test/{package_path}/{class_name}Test.java",
+                f"src/test/java/{package_path}/{class_name}Test.java",
+            ]
+        else:
+            class_name = parts[0]
+            patterns = [
+                f"{class_name}Test.java",
+                f"Test{class_name}.java",
+                f"test/{class_name}Test.java",
+            ]
+        
+        for pattern in patterns:
+            file_path = Path(self.project_dir) / pattern
+            if file_path.exists():
+                return str(file_path)
+        
+        return None

coverage_tool/test_removers/python_remover.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Python测试删除器
+使用AST解析Python测试文件
+"""
+
+import ast
+import os
+from typing import List, Optional
+from pathlib import Path
+
+from coverage_tool.test_removers.base import BaseSmartTestRemover, TestFunction
+from coverage_tool.parsers import TestCase
+
+
+class PythonSmartTestRemover(BaseSmartTestRemover):
+    """Python智能测试删除器 - 使用AST解析"""
+    
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """使用AST查找Python测试函数"""
+        test_functions = []
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            tree = ast.parse(content)
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    # 检查是否是测试函数
+                    if self._is_test_function(node):
+                        # 获取函数在文件中的位置
+                        start_line = node.lineno
+                        end_line = node.end_lineno if hasattr(node, 'end_lineno') else start_line
+                        
+                        # 获取装饰器
+                        decorators = []
+                        for decorator in node.decorator_list:
+                            if isinstance(decorator, ast.Name):
+                                decorators.append(decorator.id)
+                            elif isinstance(decorator, ast.Call):
+                                if isinstance(decorator.func, ast.Name):
+                                    decorators.append(decorator.func.id)
+                        
+                        test_func = TestFunction(
+                            name=node.name,
+                            file_path=file_path,
+                            start_line=start_line,
+                            end_line=end_line or start_line,
+                            decorators=decorators,
+                            is_class_method=self._is_class_method(node, tree),
+                            class_name=self._get_class_name(node, tree)
+                        )
+                        test_functions.append(test_func)
+                
+                elif isinstance(node, ast.ClassDef):
+                    # 处理测试类中的方法
+                    if self._is_test_class(node):
+                        for item in node.body:
+                            if isinstance(item, ast.FunctionDef) and self._is_test_method(item):
+                                start_line = item.lineno
+                                end_line = item.end_lineno if hasattr(item, 'end_lineno') else start_line
+                                
+                                test_func = TestFunction(
+                                    name=item.name,
+                                    file_path=file_path,
+                                    start_line=start_line,
+                                    end_line=end_line or start_line,
+                                    is_class_method=True,
+                                    class_name=node.name
+                                )
+                                test_functions.append(test_func)
+        
+        except SyntaxError as e:
+            self.logger.error(f"Python语法错误 {file_path}: {e}")
+        except Exception as e:
+            self.logger.error(f"解析Python文件失败 {file_path}: {e}")
+        
+        return test_functions
+    
+    def _is_test_function(self, node: ast.FunctionDef) -> bool:
+        """检查是否是测试函数"""
+        # 函数名以 test_ 开头
+        if node.name.startswith('test_'):
+            return True
+        
+        # 检查是否有测试相关的装饰器
+        test_decorators = {'pytest', 'fixture', 'parametrize'}
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name):
+                if decorator.id.lower() in test_decorators or decorator.id.startswith('pytest'):
+                    return True
+        
+        return False
+    
+    def _is_test_class(self, node: ast.ClassDef) -> bool:
+        """检查是否是测试类"""
+        # 类名以 Test 开头
+        if node.name.startswith('Test'):
+            return True
+        
+        # 检查继承
+        for base in node.bases:
+            if isinstance(base, ast.Name):
+                if 'test' in base.id.lower():
+                    return True
+        
+        return False
+    
+    def _is_test_method(self, node: ast.FunctionDef) -> bool:
+        """检查是否是测试方法"""
+        return node.name.startswith('test_')
+    
+    def _is_class_method(self, node: ast.FunctionDef, tree: ast.AST) -> bool:
+        """检查函数是否是类方法"""
+        for parent in ast.walk(tree):
+            if isinstance(parent, ast.ClassDef):
+                for item in parent.body:
+                    if isinstance(item, ast.FunctionDef) and item.name == node.name:
+                        return True
+        return False
+    
+    def _get_class_name(self, node: ast.FunctionDef, tree: ast.AST) -> Optional[str]:
+        """获取函数所属的类名"""
+        for parent in ast.walk(tree):
+            if isinstance(parent, ast.ClassDef):
+                for item in parent.body:
+                    if isinstance(item, ast.FunctionDef) and item.name == node.name:
+                        return parent.name
+        return None
+    
+    def _get_deletion_range(self, test_func: TestFunction, lines: List[str]) -> tuple:
+        """
+        获取Python测试函数的删除范围
+        考虑装饰器和空行
+        """
+        start_idx = self._adjust_start_for_decorators(
+            test_func, lines, comment_prefixes=['#']
+        )
+        end_idx = test_func.end_line
+        return start_idx, end_idx
+    
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """查找Python测试文件"""
+        classname = test_case.classname
+        
+        # 可能的文件模式
+        patterns = [
+            f"{classname.replace('.', '/')}.py",
+            f"test_{classname.replace('.', '_')}.py",
+            f"{classname.replace('.', '_')}_test.py",
+            f"tests/{classname.replace('.', '/')}.py",
+            f"tests/test_{classname.replace('.', '_')}.py",
+        ]
+        
+        for pattern in patterns:
+            file_path = Path(self.project_dir) / pattern
+            if file_path.exists():
+                return str(file_path)
+        
+        # 搜索包含测试函数的文件
+        for test_file in Path(self.project_dir).rglob("*test*.py"):
+            try:
+                with open(test_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                if f"def {test_case.name}(" in content:
+                    return str(test_file)
+            except:
+                continue
+        
+        return None

coverage_tool/utils/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""
+工具类集合包
+提供文件备份、日志、依赖分析等通用功能
+"""
+
+from .file_backup import FileBackup, FileBackupManager
+from .dependency_graph import DependencyGraph
+from .logger import Logger
+from .progress import ProgressTracker
+from .helpers import temporary_directory, safe_delete_file, find_files_by_patterns, parse_error_locations
+
+__all__ = [
+    'FileBackup',
+    'FileBackupManager',
+    'DependencyGraph',
+    'Logger',
+    'ProgressTracker',
+    'temporary_directory',
+    'safe_delete_file',
+    'find_files_by_patterns',
+    'parse_error_locations',
+]

coverage_tool/utils/dependency_graph.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+依赖关系图模块
+"""
+
+from typing import Dict, Set
+
+
+class DependencyGraph:
+    """依赖关系图"""
+    
+    def __init__(self):
+        self.dependencies: Dict[str, Set[str]] = {}  # file -> set of files it depends on
+        self.dependents: Dict[str, Set[str]] = {}    # file -> set of files that depend on it
+    
+    def add_dependency(self, file_path: str, depends_on: str):
+        """添加依赖关系"""
+        if file_path not in self.dependencies:
+            self.dependencies[file_path] = set()
+        self.dependencies[file_path].add(depends_on)
+        
+        if depends_on not in self.dependents:
+            self.dependents[depends_on] = set()
+        self.dependents[depends_on].add(file_path)
+    
+    def get_dependents(self, file_path: str) -> Set[str]:
+        """获取依赖于该文件的文件列表"""
+        return self.dependents.get(file_path, set())
+    
+    def get_dependencies(self, file_path: str) -> Set[str]:
+        """获取该文件依赖的文件列表"""
+        return self.dependencies.get(file_path, set())
+    
+    def get_impact_files(self, file_path: str) -> Set[str]:
+        """获取删除该文件会影响的所有文件（递归）"""
+        impacted = set()
+        to_process = {file_path}
+        processed = set()
+        
+        while to_process:
+            current = to_process.pop()
+            if current in processed:
+                continue
+            processed.add(current)
+            
+            dependents = self.get_dependents(current)
+            for dependent in dependents:
+                if dependent != file_path:
+                    impacted.add(dependent)
+                    to_process.add(dependent)
+        
+        return impacted

coverage_tool/utils/file_backup.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+文件备份管理模块
+"""
+
+import os
+import shutil
+import hashlib
+import tempfile
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Optional
+
+
+@dataclass
+class FileBackup:
+    """文件备份记录"""
+    original_path: str
+    backup_path: str
+    checksum: str
+    timestamp: datetime = field(default_factory=datetime.now)
+
+
+class FileBackupManager:
+    """文件备份管理器"""
+    
+    def __init__(self, backup_dir: Optional[str] = None):
+        self.backup_dir = backup_dir or tempfile.mkdtemp(prefix="coverage_backup_")
+        self.backups: Dict[str, FileBackup] = {}
+        self._ensure_backup_dir()
+    
+    def _ensure_backup_dir(self):
+        """确保备份目录存在"""
+        if not os.path.exists(self.backup_dir):
+            os.makedirs(self.backup_dir, exist_ok=True)
+    
+    def _calculate_checksum(self, file_path: str) -> str:
+        """计算文件校验和"""
+        try:
+            with open(file_path, 'rb') as f:
+                return hashlib.md5(f.read()).hexdigest()
+        except:
+            return ""
+    
+    def backup_file(self, file_path: str) -> Optional[FileBackup]:
+        """备份单个文件"""
+        if not os.path.exists(file_path):
+            return None
+        
+        # 计算相对路径
+        abs_path = os.path.abspath(file_path)
+        backup_file_path = os.path.join(
+            self.backup_dir,
+            abs_path.replace(os.sep, '_').replace(':', '_')
+        )
+        
+        # 确保备份目录存在
+        os.makedirs(os.path.dirname(backup_file_path), exist_ok=True)
+        
+        # 复制文件
+        shutil.copy2(abs_path, backup_file_path)
+        
+        # 创建备份记录
+        backup = FileBackup(
+            original_path=abs_path,
+            backup_path=backup_file_path,
+            checksum=self._calculate_checksum(abs_path)
+        )
+        
+        self.backups[abs_path] = backup
+        return backup
+    
+    def backup_files(self, file_paths: List[str]) -> List[FileBackup]:
+        """批量备份文件"""
+        backups = []
+        for file_path in file_paths:
+            backup = self.backup_file(file_path)
+            if backup:
+                backups.append(backup)
+        return backups
+    
+    def restore_file(self, file_path: str) -> bool:
+        """恢复单个文件"""
+        abs_path = os.path.abspath(file_path)
+        if abs_path not in self.backups:
+            return False
+        
+        backup = self.backups[abs_path]
+        if os.path.exists(backup.backup_path):
+            shutil.copy2(backup.backup_path, abs_path)
+            return True
+        return False
+    
+    def restore_all(self) -> List[str]:
+        """恢复所有备份的文件"""
+        restored = []
+        for file_path in self.backups:
+            if self.restore_file(file_path):
+                restored.append(file_path)
+        return restored
+    
+    def cleanup(self):
+        """清理备份目录"""
+        if os.path.exists(self.backup_dir):
+            shutil.rmtree(self.backup_dir, ignore_errors=True)
+        self.backups.clear()
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cleanup()

coverage_tool/utils/helpers.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+辅助函数模块
+"""
+
+import os
+import shutil
+import re
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from .file_backup import FileBackupManager
+
+
+@contextmanager
+def temporary_directory():
+    """临时目录上下文管理器"""
+    temp_dir = tempfile.mkdtemp()
+    try:
+        yield temp_dir
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def safe_delete_file(file_path: str, backup_manager: Optional[FileBackupManager] = None) -> bool:
+    """安全删除文件（先备份）"""
+    if not os.path.exists(file_path):
+        return False
+    
+    # 先备份
+    if backup_manager:
+        backup_manager.backup_file(file_path)
+    
+    try:
+        os.remove(file_path)
+        return True
+    except Exception as e:
+        print(f"删除文件失败 {file_path}: {e}")
+        return False
+
+
+def find_files_by_patterns(directory: str, patterns: List[str]) -> List[str]:
+    """根据多个模式查找文件"""
+    found_files = set()
+    path = Path(directory)
+    
+    for pattern in patterns:
+        for file_path in path.rglob(pattern):
+            if file_path.is_file():
+                found_files.add(str(file_path))
+    
+    return sorted(list(found_files))
+
+
+def parse_error_locations(errors: List[str], project_dir: str) -> Dict[str, List[int]]:
+    """从错误信息中解析出错的文件和行号"""
+    error_locations: Dict[str, List[int]] = {}
+    
+    # 各种编译错误模式
+    patterns = [
+        r'([^\s]+\.\w+):(\d+):',  # file:line:col
+        r'([^\s]+\.\w+)\((\d+)\)',  # file(line)
+        r'File "([^"]+)", line (\d+)',  # Python style
+        r'([^\s]+\.\w+):(\d+)',  # file:line
+    ]
+    
+    for error in errors:
+        for pattern in patterns:
+            matches = re.findall(pattern, error)
+            for match in matches:
+                if isinstance(match, tuple):
+                    file_path, line_str = match
+                else:
+                    continue
+                
+                # 规范化路径
+                if not os.path.isabs(file_path):
+                    file_path = os.path.join(project_dir, file_path)
+                file_path = os.path.normpath(file_path)
+                
+                if os.path.exists(file_path):
+                    line_num = int(line_str)
+                    if file_path not in error_locations:
+                        error_locations[file_path] = []
+                    error_locations[file_path].append(line_num)
+    
+    return error_locations