console-error-scanner 1.16.3__py3-none-any.whl

console_error_scanner/screens/error_detail.py

@@ -0,0 +1,164 @@
+"""Modal-Screen fuer Fehlerdetails."""
+
+from __future__ import annotations
+
+from urllib.parse import unquote
+
+from rich.markup import escape as escape_markup
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+from ..i18n import t
+from ..models.scan_result import ErrorType, ScanResult
+
+_TYPE_LABELS: dict[ErrorType, str] = {
+    ErrorType.CONSOLE_ERROR: "CONSOLE",
+    ErrorType.CONSOLE_WARNING: "WARNING",
+    ErrorType.HTTP_404: "HTTP 404",
+    ErrorType.HTTP_4XX: "HTTP 4xx",
+    ErrorType.HTTP_5XX: "HTTP 5xx",
+}
+
+_TYPE_STYLES: dict[ErrorType, str] = {
+    ErrorType.CONSOLE_ERROR: "bold red",
+    ErrorType.CONSOLE_WARNING: "bold yellow",
+    ErrorType.HTTP_404: "bold yellow",
+    ErrorType.HTTP_4XX: "bold yellow",
+    ErrorType.HTTP_5XX: "bold red",
+}
+
+
+class ErrorDetailScreen(ModalScreen[None]):
+    """Modal-Dialog mit ausfuehrlichen Fehlerdetails einer URL."""
+
+    DEFAULT_CSS = """
+    ErrorDetailScreen {
+        align: center middle;
+    }
+
+    ErrorDetailScreen > Vertical {
+        width: 80%;
+        max-width: 110;
+        height: auto;
+        max-height: 90%;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+
+    ErrorDetailScreen #detail-title {
+        height: auto;
+        max-height: 5;
+        content-align: center middle;
+        text-style: bold;
+        background: $accent;
+        color: auto;
+        margin-bottom: 1;
+        padding: 1 2;
+    }
+
+    ErrorDetailScreen #detail-scroll {
+        height: 1fr;
+    }
+
+    ErrorDetailScreen #detail-content {
+        height: auto;
+        padding: 1;
+    }
+
+    ErrorDetailScreen #detail-buttons {
+        height: 3;
+        align: center middle;
+        margin-top: 1;
+    }
+
+    ErrorDetailScreen #detail-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q,Q", "close", "Close"),
+    ]
+
+    def __init__(self, result: ScanResult, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._result = result
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(t("error_detail_screen.title", url=self._result.url), id="detail-title")
+            with VerticalScroll(id="detail-scroll"):
+                yield Static(self._build_markup(), id="detail-content", markup=True)
+            with Horizontal(id="detail-buttons"):
+                yield Button(t("binding.close"), variant="primary", id="detail-close")
+
+    def _link(self, text: str, target: str) -> str:
+        """Erzeugt ein Hover-klickbares Markup-Snippet (ueber ClickableLinksMixin)."""
+        link_markup = getattr(self.app, "link_markup", None)
+        if callable(link_markup):
+            return link_markup(escape_markup(text), target)
+        return escape_markup(text)
+
+    def _build_markup(self) -> str:
+        """Erstellt den Detail-Inhalt als Rich-Markup-String mit Hover-Links."""
+        result = self._result
+        parts: list[str] = []
+
+        parts.append(f"[bold]URL:[/] {self._link(result.url, result.url)}")
+        parts.append(escape_markup(t("error_detail_screen.http_status", code=result.http_status_code)))
+        parts.append(escape_markup(t("error_detail_screen.load_time", time=result.load_time_ms)))
+        parts.append(escape_markup(t("error_detail_screen.retries", count=result.retry_count)))
+        ignored_info = f", {result.ignored_count} ignored" if result.ignored_count > 0 else ""
+        parts.append(
+            escape_markup(t("error_detail_screen.total_errors", total=result.total_error_count, ignored=ignored_info))
+        )
+        parts.append("")
+
+        active_errors = [e for e in result.errors if not e.whitelisted]
+        ignored_errors = [e for e in result.errors if e.whitelisted]
+
+        if not active_errors and not ignored_errors:
+            parts.append(f"[green]{escape_markup(t('error_detail_screen.no_errors'))}[/]")
+            return "\n".join(parts)
+
+        for error in active_errors:
+            style = _TYPE_STYLES.get(error.error_type, "")
+            label = _TYPE_LABELS.get(error.error_type, "?")
+            tag = f"[{style}]\\[{label}][/]" if style else f"\\[{label}]"
+            # URLs in der Meldung sind oft percent-encoded - fuer die Anzeige
+            # dekodieren (%2F -> /, %3A -> :), spart Platz und ist lesbarer.
+            parts.append(f"{tag} {escape_markup(unquote(error.message))}")
+            if error.source:
+                source = error.source
+                if error.line_number:
+                    source += f":{error.line_number}"
+                parts.append(
+                    f"[dim]{escape_markup(t('error_detail_screen.source', source=''))}[/]"
+                    f"{self._link(unquote(source), error.source)}"
+                )
+            parts.append("")
+
+        if ignored_errors:
+            parts.append(
+                f"[dim underline]{escape_markup(t('error_detail_screen.whitelist_hits', count=len(ignored_errors)))}[/]"
+            )
+            parts.append("")
+            for error in ignored_errors:
+                label = _TYPE_LABELS.get(error.error_type, "?")
+                parts.append(f"[dim]\\[{label}] {escape_markup(unquote(error.message))}[/]")
+                parts.append("")
+
+        return "\n".join(parts)
+
+    @on(Button.Pressed, "#detail-close")
+    def _on_close_button(self) -> None:
+        self.dismiss(None)
+
+    def action_close(self) -> None:
+        self.dismiss(None)

console_error_scanner/screens/history.py

@@ -0,0 +1,187 @@
+"""History-Screen fuer Console Error Scanner.
+
+Zeigt eine Liste vergangener Scans und ermoeglicht die Wiederholung
+eines ausgewaehlten Scans.
+"""
+
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, DataTable, Static
+
+from ..i18n import t
+from ..models.history import History, HistoryEntry
+
+
+class HistoryScreen(ModalScreen[HistoryEntry | None]):
+    """Modal-Dialog zur Anzeige und Auswahl vergangener Scans.
+
+    Gibt den ausgewaehlten HistoryEntry per dismiss() zurueck
+    oder None wenn der Dialog ohne Auswahl geschlossen wird.
+    """
+
+    DEFAULT_CSS = """
+    HistoryScreen {
+        align: center middle;
+    }
+
+    HistoryScreen > Vertical {
+        width: 110;
+        height: 35;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+
+    HistoryScreen #history-title {
+        height: 3;
+        content-align: center middle;
+        text-style: bold;
+        background: $accent;
+        color: $text;
+        margin-bottom: 1;
+    }
+
+    HistoryScreen #history-empty {
+        height: auto;
+        padding: 2 4;
+        content-align: center middle;
+        color: $text-muted;
+        text-style: italic;
+    }
+
+    HistoryScreen #history-table {
+        height: 1fr;
+    }
+
+    HistoryScreen #history-buttons {
+        height: 3;
+        align: center middle;
+        margin-top: 1;
+    }
+
+    HistoryScreen #history-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q", "close", "Close"),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._entries: list[HistoryEntry] = []
+
+    def compose(self) -> ComposeResult:
+        """Erstellt das Modal-Layout."""
+        self._entries = History.load()
+
+        with Vertical():
+            yield Static(t("history.title"), id="history-title")
+
+            if not self._entries:
+                yield Static(
+                    t("history.empty"),
+                    id="history-empty",
+                )
+            else:
+                table = DataTable(id="history-table", cursor_type="row")
+                table.add_columns(
+                    t("history.col_number"),
+                    t("history.col_date"),
+                    t("history.col_url"),
+                    t("history.col_params"),
+                )
+                for idx, entry in enumerate(self._entries, start=1):
+                    # Datum kuerzen
+                    date_str = entry.timestamp[:16].replace("T", " ") if entry.timestamp else "?"
+
+                    # Hostname extrahieren
+                    from urllib.parse import urlparse
+
+                    try:
+                        host = urlparse(entry.sitemap_url).hostname or entry.sitemap_url
+                    except Exception:
+                        host = entry.sitemap_url
+
+                    # Parameter kompakt zusammenbauen
+                    params = []
+                    if entry.cookies:
+                        cookie_names = ", ".join(c.get("name", "?") for c in entry.cookies)
+                        params.append(f"--cookie {cookie_names}")
+                    if entry.whitelist_path:
+                        params.append(f"--whitelist {entry.whitelist_path}")
+                    if entry.url_filter:
+                        params.append(f"--filter {entry.url_filter}")
+                    if entry.console_level != "warn":
+                        params.append(f"--level {entry.console_level}")
+                    if entry.concurrency != 8:
+                        params.append(f"-c {entry.concurrency}")
+                    if entry.timeout != 60:
+                        params.append(f"-t {entry.timeout}")
+                    if entry.user_agent:
+                        params.append("--user-agent ...")
+                    if not entry.accept_consent:
+                        params.append("--no-consent")
+                    param_str = "  ".join(params) if params else "-"
+
+                    table.add_row(str(idx), date_str, host, param_str, key=str(idx))
+
+                yield table
+
+            with Horizontal(id="history-buttons"):
+                yield Button(t("history.btn_select"), variant="primary", id="history-select")
+                yield Button(t("history.btn_close"), variant="default", id="history-close")
+
+    def on_mount(self) -> None:
+        """Fokussiert die Tabelle nach dem Oeffnen."""
+        if self._entries:
+            try:
+                table = self.query_one("#history-table", DataTable)
+                table.focus()
+            except Exception:
+                pass
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Verarbeitet die Auswahl einer Zeile (Enter/Doppelklick).
+
+        Args:
+            event: Das RowSelected-Event mit dem Key der Zeile.
+        """
+        try:
+            idx = int(str(event.row_key.value)) - 1
+            if 0 <= idx < len(self._entries):
+                self.dismiss(self._entries[idx])
+        except (ValueError, IndexError):
+            pass
+
+    @on(Button.Pressed, "#history-select")
+    def _on_select_button(self) -> None:
+        """Übernimmt die markierte Zeile."""
+        if not self._entries:
+            self.dismiss(None)
+            return
+        try:
+            table = self.query_one("#history-table", DataTable)
+            row = table.cursor_row
+            if 0 <= row < len(self._entries):
+                self.dismiss(self._entries[row])
+                return
+        except Exception:
+            pass
+        self.dismiss(None)
+
+    @on(Button.Pressed, "#history-close")
+    def _on_close_button(self) -> None:
+        """Schließt den Dialog ohne Auswahl."""
+        self.dismiss(None)
+
+    def action_close(self) -> None:
+        """Schließt den Dialog ohne Auswahl (ESC/q)."""
+        self.dismiss(None)

console_error_scanner/screens/scan_summary.py

@@ -0,0 +1,234 @@
+"""Modal-Screen "Scan-Zusammenfassung": Site-Score + Findings + Big Fische.
+
+Wird am Ende eines Scans angezeigt: ein Gesamtscore (0-100 %), eine kurze
+Findings-Uebersicht und die groessten Seiten/Ressourcen als Balken-Chart.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import unquote, urlparse
+
+from rich.markup import escape as escape_markup
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.events import MouseMove
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+from ..i18n import t
+from ..models.scan_result import format_page_size
+from ..services.site_score import SiteScore
+from ..widgets.bar_chart import render_bars
+
+
+def _score_style(score: int) -> str:
+    """Farbstil zum Score (gruen/gelb/rot)."""
+    if score >= 75:
+        return "bold green"
+    if score >= 45:
+        return "bold yellow"
+    return "bold red"
+
+
+def _short_url(url: str) -> str:
+    """Kuerzt eine URL auf Pfad (ohne Host), max. 52 Zeichen."""
+    parsed = urlparse(url)
+    path = unquote(parsed.path) or "/"
+    return path if len(path) <= 52 else path[:51] + "…"
+
+
+class _SummaryContent(Static):
+    """Inhalts-Static der Zusammenfassung mit Hover-Tooltips pro Zeile.
+
+    Textual kennt keine Tooltips pro Text-Span - ``tooltip`` gilt immer fuer das
+    ganze Widget. Damit die abgekuerzten ("...") Links trotzdem die volle URL
+    zeigen, wird die Zeile unter dem Cursor ueber ``on_mouse_move`` ermittelt und
+    der Widget-Tooltip auf die volle URL dieser Zeile gesetzt (oder geleert).
+    """
+
+    def __init__(self, *args: object, **kwargs: object) -> None:
+        super().__init__(*args, **kwargs)  # type: ignore[arg-type]
+        # Zeilenindex (0-basiert im gerenderten Text) -> volle URL.
+        self.line_urls: dict[int, str] = {}
+
+    def on_mouse_move(self, event: MouseMove) -> None:
+        # event.offset.y ist relativ zum Widget inkl. Padding -> Padding-Top
+        # abziehen, um auf den Textzeilen-Index zu kommen.
+        pad_top = self.styles.padding.top if self.styles.padding else 0
+        url = self.line_urls.get(event.offset.y - pad_top)
+        self.tooltip = url or None
+
+
+class ScanSummaryScreen(ModalScreen[None]):
+    """Zeigt Site-Score, Findings und die Big Fische nach einem Scan."""
+
+    DEFAULT_CSS = """
+    ScanSummaryScreen {
+        align: center middle;
+    }
+
+    ScanSummaryScreen > Vertical {
+        width: 80%;
+        max-width: 110;
+        height: auto;
+        max-height: 90%;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+
+    ScanSummaryScreen #summary-title {
+        height: auto;
+        max-height: 5;
+        content-align: center middle;
+        text-style: bold;
+        background: $accent;
+        color: auto;
+        margin-bottom: 1;
+        padding: 1 2;
+    }
+
+    ScanSummaryScreen #summary-scroll {
+        /* Auf Inhaltshoehe schrumpfen (kein 1fr - das fuellt sonst den ganzen
+           verfuegbaren Platz und draengt den Button mit grosser Luecke nach
+           unten). max-height: 90% kappt bei langem Inhalt -> der Bereich
+           scrollt; bei kurzem Inhalt sitzt der (unten angedockte) Button direkt
+           darunter, ohne Luecke. */
+        height: auto;
+        max-height: 90%;
+    }
+
+    ScanSummaryScreen #summary-content {
+        height: auto;
+        padding: 1;
+    }
+
+    ScanSummaryScreen #summary-buttons {
+        /* Unten angedockt: bleibt bei langem (scrollendem) Inhalt immer sichtbar
+           und sitzt bei kurzem Inhalt direkt unter dem Scroll-Bereich. */
+        dock: bottom;
+        height: 3;
+        align: center middle;
+        margin-top: 1;
+    }
+
+    ScanSummaryScreen #summary-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q,Q", "close", "Close"),
+    ]
+
+    def __init__(self, score: SiteScore, **kwargs: object) -> None:
+        super().__init__(**kwargs)  # type: ignore[arg-type]
+        self._score = score
+        # Zeilenindex -> volle URL, wird in _build_content befuellt.
+        self._line_urls: dict[int, str] = {}
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(t("summary.title"), id="summary-title")
+            with VerticalScroll(id="summary-scroll"):
+                content = _SummaryContent(self._build_content(), id="summary-content")
+                content.line_urls = self._line_urls
+                yield content
+            with Horizontal(id="summary-buttons"):
+                yield Button(t("binding.close"), variant="primary", id="summary-close")
+
+    def _link_path(self, display: str, target: str) -> Text:
+        """Baut einen Hover-klickbaren Pfad-Text.
+
+        Args:
+            display:
+                Der angezeigte (ggf. gekuerzte) Pfad.
+            target:
+                Die vollstaendige URL, die beim Klick geoeffnet wird.
+
+        Returns:
+            Ein ``Text`` mit ``@click``-Meta - oder unverlinkt (dim), falls die
+            App keinen ``link_markup``-Helfer bereitstellt.
+        """
+        link_fn = getattr(self.app, "link_markup", None)
+        if callable(link_fn):
+            return Text.from_markup(link_fn(escape_markup(display), target))
+        return Text(display, style="dim")
+
+    def _build_content(self) -> Text:
+        s = self._score
+        text = Text()
+
+        # Grosse Score-Zeile.
+        text.append(t("summary.score_label") + " ", style="bold")
+        text.append(f"{s.score} %", style=_score_style(s.score))
+        text.append(f"  ({s.grade})", style=_score_style(s.score))
+        text.append("\n")
+        text.append(
+            t(
+                "summary.score_breakdown",
+                err=s.error_score,
+                err_w=s.error_weight,
+                size=s.size_score,
+                size_w=100 - s.error_weight,
+            ),
+            style="dim",
+        )
+        text.append("\n\n")
+
+        # Findings.
+        text.append(t("summary.findings"), style="bold underline")
+        text.append("\n")
+        text.append(t("summary.pages", total=s.total_pages, clean=s.clean_pages, err=s.pages_with_errors))
+        text.append("\n")
+        text.append(t("summary.errors", errors=s.total_errors, warnings=s.total_warnings))
+        text.append("\n")
+        text.append(t("summary.avg_size", size=format_page_size(s.avg_page_size_bytes)))
+        text.append("\n\n")
+
+        # Groesste Seiten.
+        if s.biggest_pages:
+            text.append(t("summary.biggest_pages"), style="bold underline")
+            text.append("\n")
+            # Erste Bar-Zeile liegt auf dem aktuellen Zeilenindex (= Anzahl der
+            # bisher abgeschlossenen Zeilen). Jede Bar-Zeile -> eine URL.
+            start = text.plain.count("\n")
+            for i, p in enumerate(s.biggest_pages):
+                self._line_urls[start + i] = p.url
+            rows: list[tuple[int, str, str | Text]] = [
+                (
+                    p.page_size_bytes,
+                    format_page_size(p.page_size_bytes),
+                    self._link_path(_short_url(p.url), p.url),
+                )
+                for p in s.biggest_pages
+            ]
+            text.append_text(render_bars(rows, bar_style="magenta"))
+            text.append("\n\n")
+
+        # Big Fische (groesste Einzelressourcen).
+        if s.biggest_resources:
+            text.append(t("summary.big_fish"), style="bold underline")
+            text.append("\n")
+            start = text.plain.count("\n")
+            for i, res in enumerate(s.biggest_resources):
+                self._line_urls[start + i] = res.url
+            res_rows: list[tuple[int, str, str | Text]] = []
+            for res in s.biggest_resources:
+                label = Text(f"{(res.resource_type or '?'):<10} ", style="dim")
+                label.append_text(self._link_path(_short_url(res.url), res.url))
+                res_rows.append((res.size_bytes, format_page_size(res.size_bytes), label))
+            text.append_text(render_bars(res_rows, bar_style="cyan"))
+
+        return text
+
+    @on(Button.Pressed, "#summary-close")
+    def _on_close_button(self) -> None:
+        self.dismiss(None)
+
+    def action_close(self) -> None:
+        self.dismiss(None)