testgap 0.1.0a0__py3-none-any.whl

testgap/coverage/ast_grouping.py

@@ -0,0 +1,135 @@
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from testgap.coverage.diff_coverage import UncoveredLine
+
+
+@dataclass
+class UncoveredFunction:
+    file: Path
+    qualname: str  # e.g. "ClassName.method" or "function_name"
+    start_line: int
+    end_line: int
+    source: str
+    uncovered_lines: list[int] = field(default_factory=list)
+    has_branch: bool = False
+
+    @property
+    def priority(self) -> tuple[int, int]:
+        """Sort key: branches first, then larger functions first."""
+        return (0 if self.has_branch else 1, -(self.end_line - self.start_line))
+
+
+def group_by_function(uncovered: list[UncoveredLine]) -> list[UncoveredFunction]:
+    """Group uncovered lines into the enclosing function/method."""
+    by_file: dict[Path, list[int]] = {}
+    for u in uncovered:
+        by_file.setdefault(u.file, []).append(u.line)
+
+    results: list[UncoveredFunction] = []
+    for file, lines in by_file.items():
+        results.extend(_group_in_file(file, sorted(set(lines))))
+
+    results.sort(key=lambda f: f.priority)
+    return results
+
+
+def _group_in_file(file: Path, lines: list[int]) -> list[UncoveredFunction]:
+    try:
+        source = file.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+
+    try:
+        tree = ast.parse(source, filename=str(file))
+    except SyntaxError:
+        return []
+
+    source_lines = source.splitlines()
+    functions = _collect_functions(tree)
+    if not functions:
+        return []
+
+    by_function: dict[tuple[str, int, int], list[int]] = {}
+    for line in lines:
+        owner = _find_owning_function(functions, line)
+        if owner is None:
+            continue
+        key = (owner.qualname, owner.start, owner.end)
+        by_function.setdefault(key, []).append(line)
+
+    out: list[UncoveredFunction] = []
+    for (qualname, start, end), uncov in by_function.items():
+        body_text = "\n".join(source_lines[start - 1 : end])
+        has_branch = _function_has_branch(functions_index=functions, start=start)
+        out.append(
+            UncoveredFunction(
+                file=file,
+                qualname=qualname,
+                start_line=start,
+                end_line=end,
+                source=body_text,
+                uncovered_lines=sorted(uncov),
+                has_branch=has_branch,
+            )
+        )
+    return out
+
+
+@dataclass
+class _FunctionRange:
+    qualname: str
+    start: int
+    end: int
+    node: ast.AST
+
+
+def _collect_functions(tree: ast.AST) -> list[_FunctionRange]:
+    ranges: list[_FunctionRange] = []
+
+    def visit(node: ast.AST, prefix: list[str]) -> None:
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, ast.ClassDef):
+                visit(child, [*prefix, child.name])
+            elif isinstance(child, ast.FunctionDef | ast.AsyncFunctionDef):
+                name = ".".join([*prefix, child.name]) if prefix else child.name
+                start = child.lineno
+                end = _last_line(child)
+                ranges.append(_FunctionRange(qualname=name, start=start, end=end, node=child))
+                visit(child, [*prefix, child.name])
+            else:
+                visit(child, prefix)
+
+    visit(tree, [])
+    return ranges
+
+
+def _find_owning_function(functions: list[_FunctionRange], line: int) -> _FunctionRange | None:
+    candidates = [f for f in functions if f.start <= line <= f.end]
+    if not candidates:
+        return None
+    return min(candidates, key=lambda f: f.end - f.start)
+
+
+def _last_line(node: ast.AST) -> int:
+    end = getattr(node, "end_lineno", None)
+    if end is not None:
+        return end
+    max_line = getattr(node, "lineno", 0)
+    for child in ast.walk(node):
+        line = getattr(child, "end_lineno", None) or getattr(child, "lineno", 0)
+        if line > max_line:
+            max_line = line
+    return max_line
+
+
+def _function_has_branch(*, functions_index: list[_FunctionRange], start: int) -> bool:
+    for func in functions_index:
+        if func.start != start:
+            continue
+        for node in ast.walk(func.node):
+            if isinstance(node, ast.If | ast.For | ast.While | ast.Try | ast.Match):
+                return True
+        return False
+    return False

testgap/coverage/diff_coverage.py

@@ -0,0 +1,68 @@
+import fnmatch
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from testgap.coverage.git_diff import FileLines
+
+
+@dataclass(frozen=True)
+class UncoveredLine:
+    file: Path
+    line: int
+
+
+@dataclass
+class DiffCoverageReport:
+    base_ref: str
+    head_ref: str
+    uncovered: list[UncoveredLine] = field(default_factory=list)
+    changed_total: int = 0
+    covered_total: int = 0
+
+    @property
+    def diff_coverage_pct(self) -> float:
+        if self.changed_total == 0:
+            return 100.0
+        return round((self.covered_total / self.changed_total) * 100, 1)
+
+
+def compute_diff_coverage(
+    *,
+    diff: list[FileLines],
+    executed: dict[Path, frozenset[int]],
+    base_ref: str,
+    head_ref: str = "HEAD",
+    exclude_patterns: list[str] | None = None,
+    project_root: Path,
+) -> DiffCoverageReport:
+    """Intersect git diff with coverage executed lines to find uncovered diff lines."""
+    exclude_patterns = exclude_patterns or []
+    report = DiffCoverageReport(base_ref=base_ref, head_ref=head_ref)
+
+    for file_lines in diff:
+        rel_path = _safe_relative(file_lines.path, project_root)
+        if _is_excluded(rel_path, exclude_patterns):
+            continue
+        if not file_lines.path.is_file() or file_lines.path.suffix != ".py":
+            continue
+
+        executed_for_file = executed.get(file_lines.path.resolve(), frozenset())
+        for line in sorted(file_lines.lines):
+            report.changed_total += 1
+            if line in executed_for_file:
+                report.covered_total += 1
+            else:
+                report.uncovered.append(UncoveredLine(file=file_lines.path, line=line))
+
+    return report
+
+
+def _safe_relative(path: Path, root: Path) -> str:
+    try:
+        return path.resolve().relative_to(root.resolve()).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _is_excluded(rel_path: str, patterns: list[str]) -> bool:
+    return any(fnmatch.fnmatch(rel_path, pat) for pat in patterns)

testgap/coverage/git_diff.py

@@ -0,0 +1,114 @@
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class GitDiffError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class FileLines:
+    path: Path
+    lines: frozenset[int]
+
+
+_HUNK_HEADER = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+
+def resolve_base_ref(repo_root: Path, explicit: str | None = None) -> str:
+    """Pick the base ref for the diff. Order: explicit > origin/HEAD > main > master."""
+    if explicit:
+        return explicit
+
+    candidates = ("origin/HEAD", "origin/main", "main", "origin/master", "master")
+    for ref in candidates:
+        if _ref_exists(repo_root, ref):
+            return ref
+    raise GitDiffError(
+        "Could not determine base ref. Specify one with --base or ensure "
+        "origin/HEAD / main / master exists."
+    )
+
+
+def changed_lines(
+    repo_root: Path,
+    base: str,
+    head: str = "HEAD",
+    only_paths: list[Path] | None = None,
+) -> list[FileLines]:
+    """Return per-file added/modified line numbers between base and head."""
+    cmd = ["git", "diff", "--unified=0", "--no-color", f"{base}...{head}"]
+    if only_paths:
+        cmd.append("--")
+        cmd.extend(str(p) for p in only_paths)
+
+    result = _run_git(repo_root, cmd)
+    return _parse_diff(result.stdout, repo_root)
+
+
+def _parse_diff(diff_text: str, repo_root: Path) -> list[FileLines]:
+    results: list[FileLines] = []
+    current_file: Path | None = None
+    current_lines: set[int] = set()
+
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            if current_file is not None:
+                results.append(FileLines(current_file, frozenset(current_lines)))
+            current_file = None
+            current_lines = set()
+            continue
+
+        if line.startswith("+++ "):
+            target = line[4:].strip()
+            if target == "/dev/null":
+                current_file = None
+            elif target.startswith("b/"):
+                current_file = repo_root / target[2:]
+            else:
+                current_file = repo_root / target
+            continue
+
+        if current_file is None:
+            continue
+
+        match = _HUNK_HEADER.match(line)
+        if match:
+            start = int(match.group(1))
+            count_str = match.group(2)
+            count = int(count_str) if count_str else 1
+            if count == 0:
+                continue
+            for n in range(start, start + count):
+                current_lines.add(n)
+
+    if current_file is not None:
+        results.append(FileLines(current_file, frozenset(current_lines)))
+
+    return [fl for fl in results if fl.lines]
+
+
+def _ref_exists(repo_root: Path, ref: str) -> bool:
+    result = subprocess.run(
+        ["git", "rev-parse", "--verify", "--quiet", ref],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def _run_git(repo_root: Path, args: list[str]) -> subprocess.CompletedProcess[str]:
+    try:
+        result = subprocess.run(
+            args, cwd=repo_root, capture_output=True, text=True, check=False
+        )
+    except FileNotFoundError as e:
+        raise GitDiffError("git executable not found on PATH") from e
+    if result.returncode != 0:
+        raise GitDiffError(
+            f"git {' '.join(args[1:])} failed (exit {result.returncode}):\n{result.stderr.strip()}"
+        )
+    return result

testgap/coverage/runner.py

@@ -0,0 +1,88 @@
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class CoverageError(Exception):
+    pass
+
+
+@dataclass
+class CoverageRunResult:
+    coverage_json_path: Path
+    executed_lines: dict[Path, frozenset[int]]
+    raw_pytest_exit_code: int
+
+
+def run_pytest_with_coverage(
+    project_root: Path,
+    source_paths: list[str],
+    extra_pytest_args: list[str] | None = None,
+    timeout_seconds: int = 300,
+) -> CoverageRunResult:
+    """Run pytest under coverage.py, return per-file executed line sets."""
+    output_dir = project_root / ".testgap"
+    output_dir.mkdir(exist_ok=True)
+    json_path = output_dir / "coverage.json"
+    if json_path.exists():
+        json_path.unlink()
+
+    source_args = []
+    for path in source_paths:
+        source_args.extend(["--cov", path.rstrip("/")])
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "pytest",
+        *source_args,
+        "--cov-report",
+        f"json:{json_path}",
+        "-q",
+        "--no-header",
+    ]
+    if extra_pytest_args:
+        cmd.extend(extra_pytest_args)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as e:
+        raise CoverageError(f"pytest timed out after {timeout_seconds}s") from e
+    except FileNotFoundError as e:
+        raise CoverageError("python executable not found on PATH") from e
+
+    if not json_path.is_file():
+        raise CoverageError(
+            f"coverage.json was not produced. pytest stderr:\n{result.stderr.strip()}"
+        )
+
+    executed = _parse_coverage_json(json_path, project_root)
+    return CoverageRunResult(
+        coverage_json_path=json_path,
+        executed_lines=executed,
+        raw_pytest_exit_code=result.returncode,
+    )
+
+
+def _parse_coverage_json(json_path: Path, project_root: Path) -> dict[Path, frozenset[int]]:
+    try:
+        data = json.loads(json_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as e:
+        raise CoverageError(f"failed to read {json_path}: {e}") from e
+
+    files = data.get("files", {})
+    out: dict[Path, frozenset[int]] = {}
+    for raw_path, info in files.items():
+        abs_path = (project_root / raw_path).resolve()
+        executed = info.get("executed_lines", []) or []
+        out[abs_path] = frozenset(int(n) for n in executed)
+    return out

testgap/detect/__init__.py

@@ -0,0 +1,11 @@
+from testgap.detect.layout_detect import LayoutKind, detect_layout, detect_source_paths
+from testgap.detect.pytest_detect import detect_pytest
+from testgap.detect.test_dir_detect import detect_test_dirs
+
+__all__ = [
+    "detect_pytest",
+    "detect_layout",
+    "detect_source_paths",
+    "detect_test_dirs",
+    "LayoutKind",
+]

testgap/detect/_toml.py

@@ -0,0 +1,18 @@
+import sys
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+def load_toml(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}

testgap/detect/layout_detect.py

@@ -0,0 +1,130 @@
+from configparser import ConfigParser
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+from testgap.detect._toml import load_toml
+
+_EXCLUDE_DIRS = {
+    "tests", "test", "docs", "doc", "examples", "example",
+    ".venv", "venv", "env", ".env", "build", "dist",
+    "node_modules", ".git", ".tox", ".mypy_cache", ".pytest_cache",
+    "__pycache__", ".ruff_cache",
+}
+
+
+class LayoutKind(str, Enum):
+    SRC = "src"
+    FLAT = "flat"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class LayoutDetection:
+    kind: LayoutKind
+    candidates: list[Path]
+
+
+def detect_layout(root: Path) -> LayoutDetection:
+    src_candidates = _detect_src_layout(root)
+    if src_candidates:
+        return LayoutDetection(kind=LayoutKind.SRC, candidates=src_candidates)
+
+    flat_candidates = _detect_flat_layout(root)
+    if flat_candidates:
+        return LayoutDetection(kind=LayoutKind.FLAT, candidates=flat_candidates)
+
+    return LayoutDetection(kind=LayoutKind.UNKNOWN, candidates=[])
+
+
+def detect_source_paths(root: Path) -> list[str]:
+    """Return source paths relative to root, ready for config.project.source_paths."""
+    detection = detect_layout(root)
+    if detection.kind == LayoutKind.SRC:
+        return ["src/"]
+    if detection.kind == LayoutKind.FLAT:
+        return sorted({f"{p.name}/" for p in detection.candidates})
+    return []
+
+
+def _detect_src_layout(root: Path) -> list[Path]:
+    candidates: list[Path] = []
+
+    src_dir = root / "src"
+    if src_dir.is_dir():
+        for child in src_dir.iterdir():
+            if child.is_dir() and (child / "__init__.py").is_file():
+                candidates.append(child)
+
+    pyproject = load_toml(root / "pyproject.toml")
+    if _toml_indicates_src(pyproject):
+        if src_dir.is_dir() and src_dir not in candidates:
+            candidates.append(src_dir)
+
+    if _setup_cfg_indicates_src(root / "setup.cfg") and src_dir.is_dir():
+        candidates.append(src_dir)
+
+    seen: set[Path] = set()
+    unique: list[Path] = []
+    for c in candidates:
+        if c not in seen:
+            seen.add(c)
+            unique.append(c)
+    return unique
+
+
+def _detect_flat_layout(root: Path) -> list[Path]:
+    candidates: list[Path] = []
+    for child in root.iterdir():
+        if not child.is_dir():
+            continue
+        if child.name.startswith("."):
+            continue
+        if child.name in _EXCLUDE_DIRS:
+            continue
+        if (child / "__init__.py").is_file():
+            candidates.append(child)
+    return candidates
+
+
+def _toml_indicates_src(pyproject: dict) -> bool:
+    if not pyproject:
+        return False
+
+    tool = pyproject.get("tool", {})
+
+    setuptools = tool.get("setuptools", {})
+    if setuptools.get("package-dir", {}).get("", "") == "src":
+        return True
+    pkg_find = setuptools.get("packages", {}).get("find", {})
+    if pkg_find.get("where") == ["src"] or pkg_find.get("where") == "src":
+        return True
+
+    hatch = tool.get("hatch", {}).get("build", {}).get("targets", {}).get("wheel", {})
+    packages = hatch.get("packages", [])
+    if any(str(p).startswith("src/") for p in packages):
+        return True
+
+    poetry_pkgs = tool.get("poetry", {}).get("packages", [])
+    if any(p.get("from") == "src" for p in poetry_pkgs if isinstance(p, dict)):
+        return True
+
+    return False
+
+
+def _setup_cfg_indicates_src(setup_cfg: Path) -> bool:
+    if not setup_cfg.is_file():
+        return False
+    parser = ConfigParser()
+    try:
+        parser.read(setup_cfg, encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return False
+    if parser.has_option("options", "package_dir"):
+        raw = parser.get("options", "package_dir")
+        if "=src" in raw.replace(" ", ""):
+            return True
+    if parser.has_option("options.packages.find", "where"):
+        if "src" in parser.get("options.packages.find", "where"):
+            return True
+    return False

testgap/detect/pytest_detect.py

@@ -0,0 +1,107 @@
+from configparser import ConfigParser
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from testgap.detect._toml import load_toml
+
+
+@dataclass
+class PytestDetection:
+    detected: bool
+    signals: list[str] = field(default_factory=list)
+
+
+_DEP_FILES = (
+    "requirements.txt",
+    "requirements-dev.txt",
+    "requirements-test.txt",
+    "Pipfile",
+    "poetry.lock",
+)
+
+
+def detect_pytest(root: Path) -> PytestDetection:
+    signals: list[str] = []
+
+    pyproject = load_toml(root / "pyproject.toml")
+    if "tool" in pyproject and "pytest" in pyproject.get("tool", {}):
+        signals.append("pyproject.toml:[tool.pytest.ini_options]")
+
+    if (root / "pytest.ini").is_file():
+        signals.append("pytest.ini")
+
+    setup_cfg = root / "setup.cfg"
+    if setup_cfg.is_file():
+        parser = ConfigParser()
+        try:
+            parser.read(setup_cfg, encoding="utf-8")
+            if parser.has_section("tool:pytest"):
+                signals.append("setup.cfg:[tool:pytest]")
+        except (OSError, UnicodeDecodeError):
+            pass
+
+    tox_ini = root / "tox.ini"
+    if tox_ini.is_file():
+        parser = ConfigParser()
+        try:
+            parser.read(tox_ini, encoding="utf-8")
+            if parser.has_section("pytest"):
+                signals.append("tox.ini:[pytest]")
+        except (OSError, UnicodeDecodeError):
+            pass
+
+    for conftest in (root / "conftest.py", root / "tests" / "conftest.py"):
+        if conftest.is_file():
+            signals.append(f"conftest.py at {conftest.relative_to(root)}")
+            break
+
+    if _has_pytest_in_dependencies(root, pyproject):
+        signals.append("pytest in dependencies")
+
+    if _has_test_files(root):
+        signals.append("test_*.py files present")
+
+    return PytestDetection(detected=bool(signals), signals=signals)
+
+
+def _has_pytest_in_dependencies(root: Path, pyproject: dict) -> bool:
+    project_deps = pyproject.get("project", {}).get("dependencies", []) or []
+    optional_deps = pyproject.get("project", {}).get("optional-dependencies", {}) or {}
+    poetry_deps = (
+        pyproject.get("tool", {}).get("poetry", {}).get("dependencies", {}) or {}
+    )
+    poetry_groups = pyproject.get("tool", {}).get("poetry", {}).get("group", {})
+    poetry_dev = poetry_groups.get("dev", {}).get("dependencies", {}) or {}
+
+    haystacks: list[str] = []
+    haystacks.extend(str(d) for d in project_deps)
+    for group_deps in optional_deps.values():
+        haystacks.extend(str(d) for d in group_deps)
+    haystacks.extend(poetry_deps.keys())
+    haystacks.extend(poetry_dev.keys())
+
+    if any("pytest" in h.lower() for h in haystacks):
+        return True
+
+    for filename in _DEP_FILES:
+        path = root / filename
+        if path.is_file():
+            try:
+                content = path.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                continue
+            if "pytest" in content.lower():
+                return True
+
+    return False
+
+
+def _has_test_files(root: Path) -> bool:
+    for tests_dir_name in ("tests", "test"):
+        tests_dir = root / tests_dir_name
+        if not tests_dir.is_dir():
+            continue
+        for pattern in ("test_*.py", "*_test.py"):
+            if any(tests_dir.rglob(pattern)):
+                return True
+    return False