coverage-tool 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

coverage_tool/converters/gtest_converter.py

@@ -18,7 +18,7 @@ class GTestConverter(BaseConverter):
         # Google Test 支持直接输出 XML
         # 如果已经有 XML 文件，直接返回
         if os.path.exists(xml_path):
-            with open(xml_path, 'r') as f:
+            with open(xml_path, 'r', encoding='utf-8') as f:
                 return f.read()
 
         # 解析文本输出

coverage_tool/example.py

@@ -14,7 +14,7 @@ def create_sample_python_project(project_dir):
     """创建一个示例Python项目"""
     # 创建主模块
     main_file = os.path.join(project_dir, "main.py")
-    with open(main_file, 'w') as f:
+    with open(main_file, 'w', encoding='utf-8') as f:
         f.write("""
 def add(a, b):
     return a + b
@@ -28,7 +28,7 @@ def multiply(a, b):
     
     # 创建测试文件
     test_file = os.path.join(project_dir, "test_main.py")
-    with open(test_file, 'w') as f:
+    with open(test_file, 'w', encoding='utf-8') as f:
         f.write("""
 import pytest
 from main import add, subtract, multiply

coverage_tool/handlers/compilation.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 智能编译失败处理器
-支持渐进式删除策略和依赖分析
+只处理单测文件的删除，业务代码错误直接告警用户
 """
 
 import os
@@ -15,236 +15,211 @@ 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:
+    """智能编译失败处理器 - 只删除单测文件"""
 
+    TEST_FILE_PATTERNS = {
+        'python': [
+            r'.*_test\.py$',
+            r'.*test_.+\.py$',
+            r'.*_tests\.py$',
+            r'test_.+\.py$',
+            r'.*/tests/.+\.py$',
+            r'.*/test/.+\.py$',
+        ],
+        'java': [
+            r'.*Test\.java$',
+            r'.*Tests\.java$',
+            r'.*TestCase\.java$',
+        ],
+        'go': [
+            r'.*_test\.go$',
+        ],
+        'c': [
+            r'.*_test\.c$',
+            r'.*test_.+\.c$',
+            r'.*/tests/.+\.c$',
+            r'.*/test/.+\.c$',
+        ],
+        'cpp': [
+            r'.*_test\.cpp$',
+            r'.*test_.+\.cpp$',
+            r'.*_test\.cc$',
+            r'.*test_.+\.cc$',
+            r'.*/tests/.+\.cpp$',
+            r'.*/test/.+\.cpp$',
+        ],
+    }
 
-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:
-        """确定文件优先级"""
+        self.deleted_test_files: List[str] = []
+
+    def _is_test_file(self, file_path: str, language: str = 'python') -> bool:
+        """检查是否是单测文件"""
         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]:
+        patterns = self.TEST_FILE_PATTERNS.get(language, self.TEST_FILE_PATTERNS['python'])
+        for pattern in patterns:
             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$',
+                return True
+        return False
+
+    def _is_business_code_error(self, error: str) -> bool:
+        """检查是否是业务代码错误（非单测代码错误）"""
+        business_error_keywords = [
+            'undefined reference',
+            'undefined symbol',
+            'cannot find symbol',
+            'package does not exist',
+            'class not found',
+            'method not found',
+            'variable not declared',
+            'syntax error',
+            'type error',
+            'compile error',
         ]
-        file_name = os.path.basename(file_path)
-        for pattern in test_patterns:
-            if re.match(pattern, file_name, re.IGNORECASE):
+        error_lower = error.lower()
+        return any(keyword in error_lower for keyword in business_error_keywords)
+
+    def _extract_error_directory(self, error: str) -> Optional[str]:
+        """从错误信息中提取报错文件所在目录"""
+        file_path = parse_error_locations([error], self.target_dir)
+        if file_path:
+            first_file = list(file_path.keys())[0]
+            return os.path.dirname(first_file)
+        return None
+
+    def _find_test_files_in_directory(self, directory: str, language: str) -> List[str]:
+        """查找指定目录下的所有单测文件"""
+        if not os.path.exists(directory) or not os.path.isdir(directory):
+            return []
+
+        test_files = []
+        for root, dirs, files in os.walk(directory):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if self._is_test_file(file_path, language):
+                    test_files.append(file_path)
+        return test_files
+
+    def _has_source_code_error(self, errors: List[str]) -> bool:
+        """检查错误中是否包含业务代码错误"""
+        for error in errors:
+            if self._is_business_code_error(error):
                 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], 
+        self,
+        errors: List[str],
         compile_func,
-        max_iterations: int = 10
+        language: str = 'python',
+        max_iterations: int = 1
     ) -> Tuple[bool, List[str], List[str]]:
         """
-        处理编译失败，使用渐进式删除策略
-        
+        处理编译失败 - 只删除单测文件，业务代码错误直接终止
+
         Args:
             errors: 编译错误列表
             compile_func: 编译函数，接收target_dir，返回(success, errors)
-            max_iterations: 最大尝试次数
-            
+            language: 编程语言
+            max_iterations: 最大尝试次数（建议设为1，因为只删单测文件）
+
         Returns:
-            (编译是否成功, 被删除的文件列表, 剩余的编译错误)
+            (编译是否成功, 被删除的单测文件列表, 剩余的编译错误)
         """
-        self.logger.info(f"开始处理编译失败，共 {len(errors)} 个错误")
-        
+        self.logger.warning("=" * 60)
+        self.logger.warning("检测到编译失败，开始分析错误...")
+        self.logger.warning("=" * 60)
+
         iteration = 0
-        current_errors = errors.copy()
-        
-        while iteration < max_iterations and current_errors:
+
+        while iteration < max_iterations:
             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("没有可安全删除的文件")
+
+            error_locations = parse_error_locations(errors, self.target_dir)
+
+            if not error_locations:
+                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)} 个文件"
-                    )
-            
-            # 备份并删除文件
+
+            error_dirs = set(os.path.dirname(path) for path in error_locations.keys())
+            self.logger.info(f"检测到 {len(error_dirs)} 个报错目录")
+
+            all_test_files = []
+            for error_dir in error_dirs:
+                test_files = self._find_test_files_in_directory(error_dir, language)
+                if test_files:
+                    self.logger.info(f"目录 {error_dir} 找到 {len(test_files)} 个单测文件")
+                    all_test_files.extend(test_files)
+
+            all_test_files = list(set(all_test_files))
+
+            if not all_test_files:
+                self.logger.warning("报错目录下未找到单测文件")
+                self.logger.warning("=" * 60)
+                self.logger.warning("编译错误来自业务代码，请手动修复以下问题后重试:")
+                for i, error in enumerate(errors[:5], 1):
+                    self.logger.warning(f"  [{i}] {error.strip()}")
+                if len(errors) > 5:
+                    self.logger.warning(f"  ... 共 {len(errors)} 个错误")
+                self.logger.warning("=" * 60)
+                return False, self.deleted_test_files, errors
+
+            self.logger.info(f"准备删除 {len(all_test_files)} 个单测文件")
+
             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}")
-            
+            for test_file in all_test_files:
+                if safe_delete_file(test_file, self.backup_manager):
+                    deleted_in_iteration.append(test_file)
+                    self.deleted_test_files.append(test_file)
+                    self.logger.info(f"已删除单测文件: {test_file}")
+
             if not deleted_in_iteration:
-                self.logger.warning("本轮未能删除任何文件")
+                self.logger.warning("未能删除任何单测文件")
                 break
-            
-            # 记录编译历史
-            self.compilation_history.append({
-                'iteration': iteration,
-                'deleted_files': deleted_in_iteration,
-                'error_count_before': len(current_errors)
-            })
-            
-            # 尝试重新编译
+
+            self.logger.info(f"已删除 {len(deleted_in_iteration)} 个单测文件，重新编译...")
+
             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
-    
+                self.logger.info("编译成功！")
+                return True, self.deleted_test_files, []
+
+            errors = new_errors
+
+            if iteration >= max_iterations:
+                self.logger.warning("=" * 60)
+                self.logger.warning("已删除所有相关单测文件，但编译仍未成功")
+                self.logger.warning("编译错误来自业务代码，请手动修复以下问题后重试:")
+                for i, error in enumerate(errors[:10], 1):
+                    self.logger.warning(f"  [{i}] {error.strip()}")
+                if len(errors) > 10:
+                    self.logger.warning(f"  ... 共 {len(errors)} 个错误")
+                self.logger.warning("=" * 60)
+                return False, self.deleted_test_files, errors
+
+        self.logger.error("编译修复失败")
+        return False, self.deleted_test_files, errors
+
     def restore_deleted_files(self) -> List[str]:
-        """恢复所有已删除的文件"""
+        """恢复所有已删除的单测文件"""
         restored = []
-        for file_path in self.deleted_files:
+        for file_path in self.deleted_test_files:
             if self.backup_manager.restore_file(file_path):
                 restored.append(file_path)
                 self.logger.info(f"已恢复文件: {file_path}")
-        self.deleted_files.clear()
+        self.deleted_test_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()
-    
+        return self.deleted_test_files.copy()
+
     def cleanup(self):
         """清理资源"""
         self.backup_manager.cleanup()
@@ -252,8 +227,7 @@ class SmartCompilationHandler:
 
 class CompilationErrorParser:
     """编译错误解析器"""
-    
-    # 各种语言的编译错误模式
+
     ERROR_PATTERNS = {
         'python': [
             (r'File "([^"]+\.py)", line (\d+)', 'file_and_line'),
@@ -282,18 +256,12 @@ class CompilationErrorParser:
             (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)
@@ -304,19 +272,18 @@ class CompilationErrorParser:
                     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/main.py

@@ -172,6 +172,7 @@ class CoverageTool:
         success, deleted_files, remaining_errors = handler.handle_compilation_failure(
             errors, 
             compile_func,
+            language=self.config.language.value,
             max_iterations=self.config.max_compile_iterations
         )
         

coverage_tool/runners/base.py

@@ -77,7 +77,7 @@ class CoverageExtractor:
     def _parse_go_coverage_file(coverage_out_path: str) -> float:
         """直接解析Go coverage.out文件"""
         try:
-            with open(coverage_out_path, 'r') as f:
+            with open(coverage_out_path, 'r', encoding='utf-8') as f:
                 lines = f.readlines()
             
             if not lines or not lines[0].startswith('mode:'):
@@ -108,7 +108,7 @@ class CoverageExtractor:
     def _extract_gcov_coverage(coverage_out_path: str) -> float:
         """提取gcov覆盖率"""
         try:
-            with open(coverage_out_path, 'r') as f:
+            with open(coverage_out_path, 'r', encoding='utf-8') as f:
                 content = f.read()
             
             # 尝试多种模式匹配
@@ -134,7 +134,7 @@ class CoverageExtractor:
     def _extract_generic_coverage(coverage_out_path: str) -> float:
         """通用覆盖率提取"""
         try:
-            with open(coverage_out_path, 'r') as f:
+            with open(coverage_out_path, 'r', encoding='utf-8') as f:
                 content = f.read()
             
             # 查找百分比
@@ -153,7 +153,7 @@ class CoverageExtractor:
             return 0.0
         
         try:
-            with open(jacoco_html_path, 'r') as f:
+            with open(jacoco_html_path, 'r', encoding='utf-8') as f:
                 content = f.read()
             
             # 查找Total行中的覆盖率

coverage_tool/runners/c_runner.py

@@ -25,7 +25,7 @@ class CRunner(BaseRunner):
                 xml_content = JUnitReportConverter.convert_generic_output(
                     result.stdout + result.stderr, 'cunit'
                 )
-                with open(output_file, 'w') as f:
+                with open(output_file, 'w', encoding='utf-8') as f:
                     f.write(xml_content)
                 result.junit_xml_path = output_file
             except Exception as e:

coverage_tool/runners/cpp_runner.py

@@ -25,7 +25,7 @@ class CPPRunner(BaseRunner):
                 xml_content = JUnitReportConverter.convert_generic_output(
                     result.stdout + result.stderr, 'gtest'
                 )
-                with open(output_file, 'w') as f:
+                with open(output_file, 'w', encoding='utf-8') as f:
                     f.write(xml_content)
                 result.junit_xml_path = output_file
             except Exception as e:

coverage_tool/runners/go_runner.py

@@ -82,7 +82,7 @@ class GoRunner(BaseRunner):
                     )
                     
                     if junit_result.returncode == 0 or junit_result.stdout:
-                        with open(output_file, 'w') as f:
+                        with open(output_file, 'w', encoding='utf-8') as f:
                             f.write(junit_result.stdout)
                         result.junit_xml_path = output_file
                         junit_xml_generated = True
@@ -96,7 +96,7 @@ class GoRunner(BaseRunner):
             if not junit_xml_generated:
                 try:
                     xml_content = JUnitReportConverter.convert_go_test(result.stdout)
-                    with open(output_file, 'w') as f:
+                    with open(output_file, 'w', encoding='utf-8') as f:
                         f.write(xml_content)
                     result.junit_xml_path = output_file
                     self.logger.info("[报告生成] ✓ 使用内置转换器生成 JUnit XML")

coverage_tool/runners/java_runner.py

@@ -4,6 +4,8 @@ Java单测运行器
 """
 
 import os
+import glob
+import xml.etree.ElementTree as ET
 from typing import List, Tuple
 
 from .base import BaseRunner, RunResult, CoverageExtractor
@@ -11,44 +13,91 @@ from .base import BaseRunner, RunResult, CoverageExtractor
 
 class JavaRunner(BaseRunner):
     """Java单测运行器"""
-    
+
     def run_tests(self, target_dir: str, output_file: str) -> RunResult:
         """运行Java测试"""
-        # 使用Maven运行测试
-        cmd = f"mvn test -Dtest.output={output_file}"
+        cmd = "mvn test"
         result = self._run_command(cmd, target_dir)
-        
-        # Maven通常生成surefire报告
+
         surefire_report = os.path.join(target_dir, "target", "surefire-reports")
         if os.path.exists(surefire_report):
-            # 转换surefire报告为JUnit XML
             self._convert_surefire_reports(surefire_report, output_file)
-        
+
+        if not os.path.exists(output_file):
+            junit_files = glob.glob(os.path.join(surefire_report, "*.xml"))
+            if junit_files:
+                self._merge_junit_reports(junit_files, output_file)
+
         result.junit_xml_path = output_file if os.path.exists(output_file) else None
-        result.coverage_rate = self.get_coverage(output_file)
-        
+        result.coverage_rate = self.get_coverage(target_dir)
+
         return result
-    
+
+    def _merge_junit_reports(self, junit_files: List[str], output_file: str):
+        """合并多个JUnit XML报告为一个"""
+        total_tests = 0
+        total_failures = 0
+        total_errors = 0
+        total_skipped = 0
+        test_suites = []
+
+        for junit_file in junit_files:
+            try:
+                tree = ET.parse(junit_file)
+                root = tree.getroot()
+
+                if root.tag == 'testsuites':
+                    for suite in root.findall('testsuite'):
+                        test_suites.append(suite)
+                elif root.tag == 'testsuite':
+                    test_suites.append(root)
+            except Exception as e:
+                self.logger.warning(f"解析JUnit报告失败: {junit_file}: {e}")
+
+        xml_declaration = '<?xml version="1.0" encoding="UTF-8"?>\n'
+        testsuites_elem = ET.Element('testsuites')
+
+        for suite in test_suites:
+            testsuites_elem.append(suite)
+            total_tests += int(suite.get('tests', 0))
+            total_failures += int(suite.get('failures', 0))
+            total_errors += int(suite.get('errors', 0))
+            total_skipped += int(suite.get('skipped', 0))
+
+        testsuites_elem.set('name', 'Merged Test Results')
+        testsuites_elem.set('tests', str(total_tests))
+        testsuites_elem.set('failures', str(total_failures))
+        testsuites_elem.set('errors', str(total_errors))
+        testsuites_elem.set('skipped', str(total_skipped))
+
+        tree = ET.ElementTree(testsuites_elem)
+        tree.write(output_file, encoding='UTF-8', xml_declaration=False)
+
+        with open(output_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(xml_declaration + content)
+
     def _convert_surefire_reports(self, surefire_dir: str, output_file: str):
         """转换Surefire报告为JUnit XML"""
-        # 这里简化处理，实际应该解析XML并合并
-        pass
-    
-    def get_coverage(self, output_file: str) -> float:
+        junit_files = glob.glob(os.path.join(surefire_dir, "TEST-*.xml"))
+        if junit_files:
+            self._merge_junit_reports(junit_files, output_file)
+
+    def get_coverage(self, target_dir: str) -> float:
         """获取Java覆盖率（JaCoCo）"""
-        # JaCoCo报告通常在 target/site/jacoco/index.html
-        jacoco_html = os.path.join("target", "site", "jacoco", "index.html")
+        jacoco_html = os.path.join(target_dir, "target", "site", "jacoco", "index.html")
         return CoverageExtractor.extract_from_jacoco(jacoco_html)
-    
+
     def compile(self, target_dir: str) -> Tuple[bool, List[str]]:
         """编译Java项目"""
         cmd = "mvn compile"
         result = self._run_command(cmd, target_dir)
-        
+
         errors = []
         if not result.success:
             for line in result.stderr.split('\n'):
                 if 'error:' in line.lower() or 'cannot find symbol' in line.lower():
                     errors.append(line.strip())
-        
+
         return result.success, errors

{coverage_tool-1.0.0.dist-info → coverage_tool-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coverage-tool
-Version: 1.0.0
+Version: 1.0.2
 Summary: Multi-language unit test coverage analysis tool
 Author-email: Coverage Tool <coverage@tool.dev>
 License: MIT

{coverage_tool-1.0.0.dist-info → coverage_tool-1.0.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 coverage_tool/__init__.py,sha256=0j2DaSgKbtKY7LShLYx8VHbAhD09gm8aGQI__uo4CeU,123
-coverage_tool/example.py,sha256=8d0VAve0F54wDXgKIpIgE5kn-ZzMEKDED6_74TfQMvo,2712
-coverage_tool/main.py,sha256=cyHcWEcX3fK35kyLnr1_Nwf0Ug_svcLqG8K3wXbCk14,19416
+coverage_tool/example.py,sha256=EvY25Hfos49FU5BQp1Y5RaCJwyfNNlMx_Fcl4yD_5Pc,2748
+coverage_tool/main.py,sha256=kbxkhHdI6dRtkiPk_1naidVLqp3p-ClS-Eak3p_5EKo,19465
 coverage_tool/analyzers/__init__.py,sha256=GlcdK3CsmPtnGN0P13K0F6i-dMbL03wVRepIPW3U0O0,265
 coverage_tool/analyzers/dependency.py,sha256=l6HywXXdBY506F6yzaFH-aXYYrinbWKuG3LTfT2CGJc,18759
 coverage_tool/converters/__init__.py,sha256=h3wSGZgs1x_tKMjq3ZLAJepmcBgc3fR_-cGnQydZFhM,1830
@@ -9,22 +9,22 @@ coverage_tool/converters/cunit_converter.py,sha256=_a9Tg_nSit6XlG7x7IA0oxjcGAJEK
 coverage_tool/converters/factory.py,sha256=Qzg4ZmfX9YeNx4BcPJu3n37XLcszy6ysu2B4NHs1-6w,1003
 coverage_tool/converters/generic_converter.py,sha256=35o6M5KyHxxOlX8al-nrN0dTT9v12PQF-Nc4hF7bHW8,1906
 coverage_tool/converters/go_converter.py,sha256=KoNQ4bqZrv1zeDuGWm7GUhri6QFMqolnG-GV0YIF490,6287
-coverage_tool/converters/gtest_converter.py,sha256=uTn65IvLEGy7OUTBk80uMx9o-mQ147Az0_Za7n575fI,1728
+coverage_tool/converters/gtest_converter.py,sha256=GIkGe7bkKK8oJUBC1QhxNkgctjqDnPZo4vzDKEBs100,1746
 coverage_tool/core/__init__.py,sha256=rNM16navIyNkoMKVvJsEy2zVF7jAcyHV81nOsP1gKgI,415
 coverage_tool/core/config.py,sha256=QmBxj72gcwhI-bEUDMDd7mCUPxJdn7NiO7DdfingaOA,2133
 coverage_tool/core/reporter.py,sha256=GOsOhu8JX0u9sBHhEdbHHfrEFEfvFXQDVOyTLdeeD0w,9500
 coverage_tool/handlers/__init__.py,sha256=6iAHa2i3LhqpDWqt32x98qx3-PbVeNcsDqQX6jHhm0U,253
-coverage_tool/handlers/compilation.py,sha256=7rvrMGOs9nHPF1op4RXgFzXVs1wL4Skl_pBKclQotOI,11981
+coverage_tool/handlers/compilation.py,sha256=RfGr0lCWFb5ncNvVWuzHkTk1_h-mlXNAn7S3mv8PkBw,10907
 coverage_tool/handlers/env_checker.py,sha256=L6JJE39C-9DxKKtVC_ZUi-0ONxnjREZhQKiaj8t5Uoo,12665
 coverage_tool/parsers/__init__.py,sha256=7Wmg-Tf_rAo-uD9PWZJv5gGwSeWWuzcAAO2qMm6O3QE,264
 coverage_tool/parsers/junit.py,sha256=COjG9_YWvlAsX3Ztd11ttFRRDZnpjg-BZWWwr4egVTM,5555
 coverage_tool/runners/__init__.py,sha256=w-Lnwfh-4jOdjxdSepKO-YSg4GqHmPtK6Ut6wQeQkJU,584
-coverage_tool/runners/base.py,sha256=hyaFSIFoqW35O9Vou8iI3S2S0dTWCMvhn_92spz4lv0,8078
-coverage_tool/runners/c_runner.py,sha256=DZPtEVUZXSNQLuA1nDdI449ODImT1Tkfx8q28HyC_Ko,2166
-coverage_tool/runners/cpp_runner.py,sha256=f_L1FVuLRJH4DByj6Oo7uVGodOJFUDUEosZreqf70Ko,2154
+coverage_tool/runners/base.py,sha256=bPsTFc1I-NCXKjJ0ILqYUoh54iAUylaR2dFnsUZfrYU,8150
+coverage_tool/runners/c_runner.py,sha256=bAakBnI2gvuz0Cc8Paj84NJCECBe94VDOtBFv25GVgI,2184
+coverage_tool/runners/cpp_runner.py,sha256=pormwZXQVRxdkceTjUNbXxYKp5-kYVP9vLW6qXyROXI,2172
 coverage_tool/runners/factory.py,sha256=f_oM_AQfj3Yge1Ou_XSyERbcynluBLWb4s85m7YgYWs,1187
-coverage_tool/runners/go_runner.py,sha256=FEOPpi-IMI5zu_zbzuaJ60vS0aoYJCTbRtW2q1TJEC0,6397
-coverage_tool/runners/java_runner.py,sha256=BEzaR5-4npIzmPSCO8avzktgsDp_OwjSgQxT3A8-uSI,1936
+coverage_tool/runners/go_runner.py,sha256=3ZU3YJ5nOGHti2c-KfoX-7EQVSHBoXoDEuePPM6SCsE,6433
+coverage_tool/runners/java_runner.py,sha256=yF-lMjQ2NzpOi1v9nVDBQqBLN3XM_DB4PiG1PPQK71M,3826
 coverage_tool/runners/python_runner.py,sha256=ZTOjY93ZY1vfuROM9-CX80d03AaAUA5fJhcprgWQ3Vk,3731
 coverage_tool/test_removers/__init__.py,sha256=rPbFy8DRohFctpZgBz-QR-mld0rxqBg4G4KHjKQqGgI,958
 coverage_tool/test_removers/base.py,sha256=LYvG0ZRcsbsI4p_h3HvwvStfO1-6i_ARzaupNFCE3BE,8911
@@ -40,8 +40,8 @@ coverage_tool/utils/file_backup.py,sha256=SSrVGAPlO-Lz4cx-dFLhRwonbL8V0h0siBm0ZP
 coverage_tool/utils/helpers.py,sha256=t2aWyMtV_r1EGFli40q1H1gGmibNrpjd5pFlhXNEX0w,2587
 coverage_tool/utils/logger.py,sha256=FGRPw39iXCT-VwrY4VOLpL_z2hALeYv4QAcYNC7SUsA,1596
 coverage_tool/utils/progress.py,sha256=o8t-FvrEMN4oYSK-cq_ywnkMES5szCwNhl546i0JpUU,1312
-coverage_tool-1.0.0.dist-info/METADATA,sha256=R5Q1L9EajJkA1YU94J1Fj4ZkNmoJWoZ71bIk13yaacU,13751
-coverage_tool-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-coverage_tool-1.0.0.dist-info/entry_points.txt,sha256=gpUjpKt5x923IqF_YogfB-DMj_AhMyGivppNG61H7ig,58
-coverage_tool-1.0.0.dist-info/top_level.txt,sha256=QXoWKxLBHkNWJAlCFZjqCuunXV-6uWjUhc0ni4enaYo,14
-coverage_tool-1.0.0.dist-info/RECORD,,
+coverage_tool-1.0.2.dist-info/METADATA,sha256=0aD4WA8aZJauxacL_rMmQuXQLz5DzYmK_qwEqsCHXGs,13751
+coverage_tool-1.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+coverage_tool-1.0.2.dist-info/entry_points.txt,sha256=gpUjpKt5x923IqF_YogfB-DMj_AhMyGivppNG61H7ig,58
+coverage_tool-1.0.2.dist-info/top_level.txt,sha256=QXoWKxLBHkNWJAlCFZjqCuunXV-6uWjUhc0ni4enaYo,14
+coverage_tool-1.0.2.dist-info/RECORD,,