crackerjack 0.18.2__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/coverage_badge_service.py

@@ -0,0 +1,173 @@
+from contextlib import suppress
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+from .regex_patterns import SAFE_PATTERNS
+
+
+class CoverageBadgeService:
+    """Service for managing coverage badges in README.md files."""
+
+    @depends.inject
+    def __init__(self, console: Inject[Console], project_root: Path) -> None:
+        self.console = console
+        self.project_root = project_root
+        self.readme_path = project_root / "README.md"
+
+    def update_readme_coverage_badge(self, coverage_percent: float) -> bool:
+        """Update or insert coverage badge in README.md with current coverage percentage."""
+        if not self.readme_path.exists():
+            self.console.print(
+                "[yellow]⚠️[/yellow] README.md not found, skipping badge update"
+            )
+            return False
+
+        try:
+            readme_content = self.readme_path.read_text(encoding="utf-8")
+            badge_url = self._generate_badge_url(coverage_percent)
+
+            if self._has_coverage_badge(readme_content):
+                updated_content = self._update_existing_badge(readme_content, badge_url)
+                action = "updated"
+            else:
+                updated_content = self._insert_new_badge(readme_content, badge_url)
+                action = "added"
+
+            if updated_content != readme_content:
+                self.readme_path.write_text(updated_content, encoding="utf-8")
+                self.console.print(
+                    f"[green]📊[/green] Coverage badge {action}: {coverage_percent:.1f}%"
+                )
+                return True
+            else:
+                return False
+
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Failed to update coverage badge: {e}")
+            return False
+
+    def _generate_badge_url(self, coverage_percent: float) -> str:
+        """Generate shields.io badge URL with appropriate color coding."""
+        color = self._get_badge_color(coverage_percent)
+        # URL encode the % symbol as %25
+        encoded_percent = f"{coverage_percent:.1f}%25"
+        return f"https://img.shields.io/badge/coverage-{encoded_percent}-{color}"
+
+    def _get_badge_color(self, coverage_percent: float) -> str:
+        """Determine badge color based on coverage percentage."""
+        if coverage_percent < 50:
+            return "red"
+        elif coverage_percent < 80:
+            return "yellow"
+        return "brightgreen"
+
+    def _has_coverage_badge(self, content: str) -> bool:
+        """Check if README already contains a coverage badge."""
+        # Use safe pattern for badge detection
+        return SAFE_PATTERNS["detect_coverage_badge"].search(content) is not None
+
+    def _update_existing_badge(self, content: str, new_badge_url: str) -> str:
+        """Replace existing coverage badge with new one."""
+        # Try different safe patterns for badge replacement
+        patterns_to_try = [
+            "update_coverage_badge_url",
+            "update_coverage_badge_any",
+            "update_shields_coverage_url",
+        ]
+
+        for pattern_name in patterns_to_try:
+            pattern_obj = SAFE_PATTERNS[pattern_name]
+            # Use the pattern and manually replace NEW_BADGE_URL with actual URL
+            temp_content = pattern_obj.apply(content)
+            if temp_content != content:
+                # Replace placeholder with actual URL
+                new_content = temp_content.replace("NEW_BADGE_URL", new_badge_url)
+                return new_content
+
+        return content
+
+    def _insert_new_badge(self, content: str, badge_url: str) -> str:
+        """Insert new coverage badge in the appropriate location."""
+        lines = content.split("\n")
+
+        # Find the badge section (after title, before first heading)
+        insert_index = self._find_badge_insertion_point(lines)
+
+        if insert_index is not None:
+            coverage_badge = f"![Coverage]({badge_url})"
+            lines.insert(insert_index, coverage_badge)
+            return "\n".join(lines)
+        # Fallback: add after title
+        return self._insert_after_title(content, badge_url)
+
+    def _find_badge_insertion_point(self, lines: list[str]) -> int | None:
+        """Find the best location to insert the coverage badge."""
+        # Look for existing badge lines
+        badge_lines = [
+            i for i, line in enumerate(lines) if line.strip().startswith(("[![", "!["))
+        ]
+
+        if badge_lines:
+            # Insert after the last existing badge
+            return badge_lines[-1] + 1
+
+        # Look for first non-empty line after title
+        title_found = False
+        for i, line in enumerate(lines):
+            if line.startswith("#") and not title_found:
+                title_found = True
+                continue
+            elif title_found and line.strip() == "":
+                continue
+            elif title_found and line.strip():
+                return i
+
+        return None
+
+    def _insert_after_title(self, content: str, badge_url: str) -> str:
+        """Fallback method to insert badge after the title."""
+        lines = content.split("\n")
+
+        # Find title line
+        for i, line in enumerate(lines):
+            if line.startswith("#"):
+                # Insert after title with blank line
+                coverage_badge = f"![Coverage]({badge_url})"
+                if i + 1 < len(lines) and lines[i + 1].strip() == "":
+                    lines.insert(i + 2, coverage_badge)
+                else:
+                    lines.insert(i + 1, "")
+                    lines.insert(i + 2, coverage_badge)
+                break
+
+        return "\n".join(lines)
+
+    def should_update_badge(self, coverage_percent: float) -> bool:
+        """Check if badge should be updated based on coverage change."""
+        if not self.readme_path.exists():
+            return False
+
+        try:
+            content = self.readme_path.read_text(encoding="utf-8")
+            current_coverage = self._extract_current_coverage(content)
+
+            if current_coverage is None:
+                return True  # No badge exists, should add one
+
+            # Only update if coverage changed by at least 0.01% (more accurate reporting)
+            return abs(coverage_percent - current_coverage) >= 0.01
+
+        except Exception:
+            return True  # On error, attempt update
+
+    def _extract_current_coverage(self, content: str) -> float | None:
+        """Extract current coverage percentage from existing badge."""
+        match = SAFE_PATTERNS["extract_coverage_percentage"].search(content)
+
+        if match:
+            with suppress(ValueError):
+                return float(match.group(1))
+
+        return None

crackerjack/services/coverage_ratchet.py

@@ -0,0 +1,381 @@
+import json
+import typing as t
+from datetime import datetime
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+from crackerjack.models.protocols import CoverageRatchetProtocol
+from crackerjack.services.filesystem import FileSystemService
+from crackerjack.services.regex_patterns import update_coverage_requirement
+
+
+class CoverageRatchetService(CoverageRatchetProtocol):
+    MILESTONES = [15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 95, 100]
+
+    TOLERANCE_MARGIN = 2.0
+
+    @depends.inject
+    def __init__(self, pkg_path: Path, console: Inject[Console]) -> None:
+        # Normalize to pathlib.Path to avoid async path behaviors
+        try:
+            self.pkg_path = Path(str(pkg_path))
+        except Exception:
+            self.pkg_path = Path(pkg_path)
+        self.console = console
+        self.ratchet_file = self.pkg_path / ".coverage-ratchet.json"
+        self.pyproject_file = self.pkg_path / "pyproject.toml"
+
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
+    def initialize_baseline(self, initial_coverage: float) -> None:
+        if self.ratchet_file.exists():
+            return
+
+        ratchet_data: dict[str, t.Any] = {
+            "baseline": initial_coverage,
+            "current_minimum": initial_coverage,
+            "target": 100.0,
+            "last_updated": datetime.now().isoformat(),
+            "history": [
+                {
+                    "date": datetime.now().isoformat(),
+                    "coverage": initial_coverage,
+                    "commit": "baseline",
+                    "milestone": False,
+                }
+            ],
+            "milestones_achieved": [],
+            "next_milestone": self._get_next_milestone(initial_coverage),
+        }
+
+        self.ratchet_file.write_text(json.dumps(ratchet_data, indent=2))
+        self.console.print(
+            f"[cyan]📊[/ cyan] Coverage ratchet initialized at {initial_coverage: .2f}% baseline"
+        )
+
+    def get_ratchet_data(self) -> dict[str, t.Any]:
+        if not self.ratchet_file.exists():
+            return {}
+        return t.cast(dict[str, t.Any], json.loads(self.ratchet_file.read_text()))
+
+    def get_status_report(self) -> dict[str, t.Any]:
+        """Get status report for coverage ratchet service."""
+        return self.get_ratchet_data()
+
+    def get_baseline(self) -> float:
+        data = self.get_ratchet_data()
+        baseline = data.get("baseline")
+        return float(baseline) if baseline is not None else 0.0
+
+    def get_baseline_coverage(self) -> float:
+        return self.get_baseline()
+
+    def update_baseline_coverage(self, new_coverage: float) -> bool:
+        result: bool = self.update_coverage(new_coverage).get("success", False)
+        return result
+
+    def is_coverage_regression(self, current_coverage: float) -> bool:
+        baseline = self.get_baseline()
+        return current_coverage < (baseline - self.TOLERANCE_MARGIN)
+
+    def calculate_coverage_gap(self) -> float:
+        data = self.get_ratchet_data()
+        baseline = data.get("baseline")
+        baseline = float(baseline) if baseline is not None else 0.0
+        next_milestone = data.get("next_milestone")
+        next_milestone = float(next_milestone) if next_milestone is not None else None
+        if next_milestone:
+            return next_milestone - baseline
+        return 100.0 - baseline
+
+    def update_coverage(self, new_coverage: float) -> dict[str, t.Any]:
+        if not self.ratchet_file.exists():
+            self.initialize_baseline(new_coverage)
+            return {
+                "status": "initialized",
+                "message": f"Coverage ratchet initialized at {new_coverage: .2f}%",
+                "milestones": [],
+                "progress_to_100": f"{new_coverage: .1f}% of the way to 100 % coverage",
+                "allowed": True,
+                "baseline_updated": True,
+            }
+
+        data = self.get_ratchet_data()
+        current_baseline = data["baseline"]
+
+        tolerance_threshold = current_baseline - self.TOLERANCE_MARGIN
+        if new_coverage < tolerance_threshold:
+            return {
+                "status": "regression",
+                "message": f"Coverage decreased from {current_baseline: .2f}% to {new_coverage: .2f}% (below {self.TOLERANCE_MARGIN}% tolerance margin)",
+                "regression_amount": current_baseline - new_coverage,
+                "tolerance_threshold": tolerance_threshold,
+                "allowed": False,
+                "baseline_updated": False,
+            }
+        elif new_coverage > current_baseline + 0.01:
+            milestones_hit = self._check_milestones(
+                current_baseline, new_coverage, data
+            )
+            self._update_baseline(new_coverage, data, milestones_hit)
+            self._update_pyproject_requirement(new_coverage)
+
+            return {
+                "status": "improved",
+                "message": f"Coverage improved from {current_baseline: .2f}% to {new_coverage: .2f}% !",
+                "improvement": new_coverage - current_baseline,
+                "milestones": milestones_hit,
+                "progress_to_100": f"{new_coverage: .1f}% of the way to 100 % coverage",
+                "next_milestone": self._get_next_milestone(new_coverage),
+                "points_to_next": (next_milestone - new_coverage)
+                if (next_milestone := self._get_next_milestone(new_coverage))
+                is not None
+                else 0,
+                "allowed": True,
+                "baseline_updated": True,
+            }
+
+        return {
+            "status": "maintained",
+            "message": f"Coverage maintained at {new_coverage: .2f}% (within {self.TOLERANCE_MARGIN}% tolerance margin)",
+            "allowed": True,
+            "baseline_updated": False,
+        }
+
+    def _check_milestones(
+        self, old_coverage: float, new_coverage: float, data: dict[str, t.Any]
+    ) -> list[float]:
+        achieved_milestones = set(data.get("milestones_achieved", []))
+        return [
+            milestone
+            for milestone in self.MILESTONES
+            if (
+                old_coverage < milestone <= new_coverage
+                and milestone not in achieved_milestones
+            )
+        ]
+
+    def _get_next_milestone(self, coverage: float) -> float | None:
+        for milestone in self.MILESTONES:
+            if milestone > coverage:
+                return milestone
+        return None
+
+    def _update_baseline(
+        self, new_coverage: float, data: dict[str, t.Any], milestones_hit: list[float]
+    ) -> None:
+        data["baseline"] = new_coverage
+        data["current_minimum"] = new_coverage
+        data["last_updated"] = datetime.now().isoformat()
+
+        data["history"].append(
+            {
+                "date": datetime.now().isoformat(),
+                "coverage": new_coverage,
+                "commit": "current",
+                "milestone": len(milestones_hit) > 0,
+                "milestones_hit": milestones_hit,
+            }
+        )
+
+        for milestone in milestones_hit:
+            if milestone not in data["milestones_achieved"]:
+                data["milestones_achieved"].append(milestone)
+
+        data["next_milestone"] = self._get_next_milestone(new_coverage)
+
+        if len(data["history"]) > 50:
+            data["history"] = data["history"][-50:]
+
+        self.ratchet_file.write_text(json.dumps(data, indent=2))
+
+    def _update_pyproject_requirement(self, new_coverage: float) -> None:
+        try:
+            content = self.pyproject_file.read_text()
+
+            updated_content = update_coverage_requirement(content, new_coverage)
+
+            if updated_content != content:
+                updated_content = (
+                    FileSystemService.clean_trailing_whitespace_and_newlines(
+                        updated_content
+                    )
+                )
+
+                self.pyproject_file.write_text(updated_content)
+                self.console.print(
+                    f"[cyan]📝[/ cyan] Updated pyproject.toml coverage requirement to {new_coverage: .0f}%"
+                )
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/ yellow] Failed to update pyproject.toml: {e}"
+            )
+
+    def get_progress_visualization(self) -> str:
+        data = self.get_ratchet_data()
+        if not data:
+            return "Coverage ratchet not initialized"
+
+        current = data["baseline"]
+        target = 100.0
+        next_milestone = data.get("next_milestone")
+
+        progress_chars = int(current / target * 20)
+        bar = "█" * progress_chars + "░" * (20 - progress_chars)
+
+        result = f"Coverage Progress: {current: .2f}% [{bar}] → 100 %\n"
+        result += f" Current ─┘{'': > 18} └─ Goal\n"
+
+        if next_milestone:
+            points_needed = next_milestone - current
+            result += f"Next milestone: {next_milestone: .0f}% (+{points_needed: .2f}% needed)\n"
+
+        return result
+
+    def get_coverage_improvement_needed(self) -> float:
+        """Get percentage improvement needed to reach next milestone."""
+        current = self.get_baseline_coverage()
+        for milestone in self.MILESTONES:
+            if current < milestone:
+                needed = milestone - current
+                return max(0.0, needed)
+        return 0.0
+
+    def _calculate_trend(self, data: dict[str, t.Any]) -> str:
+        history = data.get("history", [])
+        if len(history) < 2:
+            return "insufficient_data"
+
+        recent_entries = history[-5:]
+        if len(recent_entries) < 2:
+            return "insufficient_data"
+
+        start_coverage = recent_entries[0]["coverage"]
+        end_coverage = recent_entries[-1]["coverage"]
+
+        if end_coverage > start_coverage + 0.5:
+            return "improving"
+        elif end_coverage < start_coverage - 0.5:
+            return "declining"
+        return "stable"
+
+    def display_milestone_celebration(self, milestones: list[float]) -> None:
+        for milestone in milestones:
+            if milestone == 100.0:
+                self.console.print(
+                    "[gold]🎉🏆 PERFECT ! 100 % COVERAGE ACHIEVED ! 🏆🎉[/ gold]"
+                )
+            elif milestone >= 90:
+                self.console.print(
+                    f"[gold]🏆 Milestone achieved: {milestone: .0f}% coverage ! Approaching perfection ![/ gold]"
+                )
+            elif milestone >= 50:
+                self.console.print(
+                    f"[green]🎯 Milestone achieved: {milestone: .0f}% coverage ! Great progress ![/ green]"
+                )
+            else:
+                self.console.print(
+                    f"[cyan]📈 Milestone achieved: {milestone: .0f}% coverage ! Keep it up ![/ cyan]"
+                )
+
+    def show_progress_with_spinner(self) -> None:
+        data = self.get_ratchet_data()
+        if not data:
+            return
+
+        current = data["baseline"]
+        target = 100.0
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage: > 3.0f}%"),
+        ) as progress:
+            task = progress.add_task(
+                "Coverage Progress", total=target, completed=current
+            )
+            progress.update(task, description=f"Coverage: {current: .1f}% / 100 %")
+
+    def get_coverage_report(self) -> str | None:
+        data = self.get_ratchet_data()
+        if not data:
+            return None
+
+        current_coverage = data.get("baseline", 0.0)
+        next_milestone = data.get("next_milestone")
+
+        report = f"Coverage: {current_coverage: .2f}%"
+        if next_milestone:
+            progress = (current_coverage / next_milestone) * 100
+            report += (
+                f" (next milestone: {next_milestone: .0f}%, {progress: .1f}% there)"
+            )
+
+        return report
+
+    def check_and_update_coverage(self) -> dict[str, t.Any]:
+        try:
+            coverage_file = self.pkg_path / "coverage.json"
+            if not coverage_file.exists():
+                return {
+                    "success": True,
+                    "status": "no_coverage_data",
+                    "message": "No coverage data found-tests passed without coverage",
+                    "allowed": True,
+                    "baseline_updated": False,
+                }
+
+            coverage_data = json.loads(coverage_file.read_text())
+            current_coverage = coverage_data.get("totals", {}).get(
+                "percent_covered", 0.0
+            )
+
+            result = self.update_coverage(current_coverage)
+            result["success"] = result.get("allowed", True)
+            return result
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": "Failed to read coverage data",
+            }