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

console_error_scanner/screens/settings.py

@@ -0,0 +1,292 @@
+"""Settings-Dialog fuer den Console Error Scanner.
+
+Erbt vom standardisierten ``BaseSettingsScreen`` (textual-widgets): die Basis
+liefert Look, Sprach-Tab und Save/Cancel; diese Klasse ergaenzt nur den
+Scanner-Tab mit den App-spezifischen Optionen.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import Checkbox, Input, Label, Select, Static, TabPane
+from textual_slider import Slider
+from textual_widgets import BaseSettingsScreen
+
+from ..i18n import t
+from ..models.history import History
+from ..models.settings import CRASH_LOG_NAME, SETTINGS_FILE
+
+
+class ScannerSettingsScreen(BaseSettingsScreen):
+    """Settings: Sprache (von der Basis) + Scanner-Optionen."""
+
+    DEFAULT_CSS = """
+    /* Label-Spalte: Label + (?)-Icon nebeneinander, gemeinsame feste Breite,
+       damit alle Eingabefelder bündig untereinander stehen. Breite muss das
+       laengste Label ("Groessen-Warnung (MB)" / "Size warning (MB)") plus das
+       (?)-Icon fassen, sonst wird das Icon abgeschnitten. */
+    ScannerSettingsScreen .label-with-icon {
+        width: 26;
+        height: 1;
+    }
+    ScannerSettingsScreen .label-with-icon Label {
+        width: auto;
+        padding: 0 1 0 1;
+    }
+    ScannerSettingsScreen .info-icon {
+        width: auto;
+        height: 1;
+        color: cyan;
+        text-style: bold;
+        padding: 0 1 0 0;
+    }
+    ScannerSettingsScreen .info-icon:hover {
+        color: white;
+        background: cyan 30%;
+    }
+    ScannerSettingsScreen .rate-value {
+        padding: 0 1;
+    }
+    ScannerSettingsScreen .rate-value.off {
+        color: $text-disabled;
+    }
+    ScannerSettingsScreen #set-rate {
+        width: 1fr;
+        margin: 0 1;
+    }
+    """
+
+    def app_tabs(self) -> ComposeResult:
+        """Scanner-Tab: Consent, Scroll, Concurrency, Timeout, Whitelist, …"""
+        with TabPane(t("settings.tab_scanner"), id="settings-tab-scanner"), VerticalScroll():
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.consent_label"), t("settings.consent_tip"))
+                yield Checkbox(
+                    t("settings.consent_checkbox"),
+                    value=bool(self._settings.get("accept_consent", True)),
+                    id="set-consent",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.scroll_label"), t("settings.scroll_tip"))
+                yield Checkbox(
+                    t("settings.scroll_checkbox"),
+                    value=bool(self._settings.get("trigger_lazy_load", True)),
+                    id="set-scroll",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.robots_label"), t("settings.robots_tip"))
+                yield Checkbox(
+                    t("settings.robots_checkbox"),
+                    value=bool(self._settings.get("respect_robots", True)),
+                    id="set-robots",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.concurrency_label"), t("settings.concurrency_tip"))
+                yield Input(
+                    value=str(self._settings.get("concurrency", 8)),
+                    type="integer",
+                    id="set-concurrency",
+                )
+            rate_on = bool(self._settings.get("rate_limit_enabled", True))
+            rate_value = self._clamp(self._settings.get("rate_per_minute", 60), 60, 10, 240)
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.rate_label"), t("settings.rate_tip"))
+                yield Checkbox(
+                    t("settings.rate_checkbox"),
+                    value=rate_on,
+                    id="set-rate-on",
+                )
+            yield Static(
+                self._rate_label(rate_value),
+                id="rate-value",
+                classes="rate-value" if rate_on else "rate-value off",
+            )
+            yield Slider(min=10, max=240, step=10, value=rate_value, id="set-rate", disabled=not rate_on)
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.timeout_label"), t("settings.timeout_tip"))
+                yield Input(
+                    value=str(self._settings.get("timeout", 60)),
+                    type="integer",
+                    id="set-timeout",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.size_warn_label"), t("settings.size_warn_tip"))
+                yield Input(
+                    value=str(self._settings.get("size_warn_mb", 10)),
+                    type="integer",
+                    id="set-size-warn",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.score_weight_label"), t("settings.score_weight_tip"))
+                yield Input(
+                    value=str(self._settings.get("score_error_weight", 60)),
+                    type="integer",
+                    id="set-score-weight",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.console_level_label"), t("settings.console_level_tip"))
+                yield Select(
+                    [("error", "error"), ("warn", "warn"), ("all", "all")],
+                    value=str(self._settings.get("console_level", "warn")),
+                    allow_blank=False,
+                    id="set-console-level",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.preview_label"), t("settings.preview_tip"))
+                yield Checkbox(
+                    t("settings.preview_checkbox"),
+                    value=bool(self._settings.get("show_preview", False)),
+                    id="set-preview",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.headless_label"), t("settings.headless_tip"))
+                yield Checkbox(
+                    t("settings.headless_checkbox"),
+                    value=bool(self._settings.get("no_headless", False)),
+                    id="set-no-headless",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.whitelist_label"), t("settings.whitelist_tip"))
+                yield Input(
+                    value=str(self._settings.get("whitelist_path", "")),
+                    placeholder=t("settings.whitelist_placeholder"),
+                    id="set-whitelist",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.user_agent_label"), t("settings.user_agent_tip"))
+                yield Input(
+                    value=str(self._settings.get("user_agent", "")),
+                    placeholder=t("settings.user_agent_placeholder"),
+                    id="set-user-agent",
+                )
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.cookies_label"), t("settings.cookies_tip"))
+                yield Input(
+                    value=str(self._settings.get("cookies", "")),
+                    placeholder=t("settings.cookies_placeholder"),
+                    id="set-cookies",
+                )
+            yield Static(t("settings.app_hint"), classes="settings-hint")
+
+        with TabPane(t("settings.tab_network"), id="settings-tab-network"), VerticalScroll():
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.proxy_url_label"), t("settings.proxy_url_tip"))
+                yield Input(
+                    value=str(self._settings.get("proxy_url", "")),
+                    placeholder="http://proxy.example.com:8080",
+                    id="set-proxy-url",
+                )
+            yield Static(t("settings.proxy_hint"), classes="settings-hint")
+
+        with TabPane(t("settings.tab_export"), id="settings-tab-export"), VerticalScroll():
+            with Horizontal(classes="settings-row"):
+                yield from self._label_with_icon(t("settings.jira_format_label"), t("settings.jira_format_tip"))
+                yield Select(
+                    [
+                        (t("settings.jira_format_markdown"), "markdown"),
+                        (t("settings.jira_format_wiki"), "wiki"),
+                    ],
+                    value=str(self._settings.get("jira_format", "markdown")),
+                    allow_blank=False,
+                    id="set-jira-format",
+                )
+            yield Static(t("settings.jira_format_hint"), classes="settings-hint")
+
+    @staticmethod
+    def _clamp(value: object, default: int, lo: int, hi: int) -> int:
+        """Begrenzt einen gespeicherten Wert auf den Bereich des Reglers."""
+        try:
+            return max(lo, min(hi, int(str(value))))
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _rate_label(per_minute: int) -> str:
+        """Uebersetzt die Reglerstellung in Klartext (Zahl + Einordnung)."""
+        if per_minute <= 30:
+            step = t("settings.rate_step_gentle")
+        elif per_minute <= 90:
+            step = t("settings.rate_step_careful")
+        elif per_minute <= 150:
+            step = t("settings.rate_step_brisk")
+        else:
+            step = t("settings.rate_step_reckless")
+        return t("settings.rate_value", count=per_minute, step=step)
+
+    @on(Slider.Changed, "#set-rate")
+    def _on_rate_changed(self, event: Slider.Changed) -> None:
+        """Haelt die Beschriftung ueber dem Regler am aktuellen Wert."""
+        self.query_one("#rate-value", Static).update(self._rate_label(int(event.slider.value)))
+
+    @on(Checkbox.Changed, "#set-rate-on")
+    def _on_rate_toggled(self, event: Checkbox.Changed) -> None:
+        """Sperrt den Regler, solange nicht gedrosselt wird."""
+        enabled = bool(event.value)
+        self.query_one("#set-rate", Slider).disabled = not enabled
+        self.query_one("#rate-value", Static).set_class(not enabled, "off")
+
+    def _label_with_icon(self, label_text: str, tip: str) -> ComposeResult:
+        """Erzeugt Label + (?)-Hover-Tooltip-Icon in der Label-Spalte."""
+        with Horizontal(classes="label-with-icon"):
+            yield Label(label_text)
+            icon = Static(t("settings.info_icon"), classes="info-icon")
+            icon.tooltip = tip
+            yield icon
+
+    def collect_app_settings(self, settings: dict[str, object]) -> None:
+        """Schreibt die Scanner-Optionen aus den Widgets ins Ergebnis-Dict."""
+        settings["accept_consent"] = self.query_one("#set-consent", Checkbox).value
+        settings["trigger_lazy_load"] = self.query_one("#set-scroll", Checkbox).value
+        settings["respect_robots"] = self.query_one("#set-robots", Checkbox).value
+        settings["concurrency"] = self._int("#set-concurrency", 8)
+        settings["rate_limit_enabled"] = self.query_one("#set-rate-on", Checkbox).value
+        settings["rate_per_minute"] = int(self.query_one("#set-rate", Slider).value)
+        settings["timeout"] = self._int("#set-timeout", 60, minimum=5)
+        settings["size_warn_mb"] = self._int("#set-size-warn", 10, minimum=0)
+        settings["score_error_weight"] = min(100, self._int("#set-score-weight", 60, minimum=0))
+        level_select = self.query_one("#set-console-level", Select)
+        level_value = level_select.value
+        settings["console_level"] = str(level_value) if level_value is not Select.BLANK else "warn"
+        settings["show_preview"] = self.query_one("#set-preview", Checkbox).value
+        settings["no_headless"] = self.query_one("#set-no-headless", Checkbox).value
+        settings["whitelist_path"] = self.query_one("#set-whitelist", Input).value.strip()
+        settings["user_agent"] = self.query_one("#set-user-agent", Input).value.strip()
+        settings["cookies"] = self.query_one("#set-cookies", Input).value.strip()
+        settings["proxy_url"] = self.query_one("#set-proxy-url", Input).value.strip()
+        jira_select = self.query_one("#set-jira-format", Select)
+        jira_value = jira_select.value
+        settings["jira_format"] = str(jira_value) if jira_value is not Select.BLANK else "markdown"
+
+    def storage_paths(self) -> list[tuple[str, Path]]:
+        """Liefert die Persistenz-Pfade fuer den Speicherort-Tab."""
+        from ..services.preview_service import CACHE_DIR as PREVIEW_CACHE_DIR
+
+        paths: list[tuple[str, Path]] = [
+            (t("settings.storage.config"), SETTINGS_FILE),
+            (t("settings.storage.history"), History.HISTORY_FILE),
+        ]
+        whitelist_raw = str(self._settings.get("whitelist_path", "")).strip()
+        if whitelist_raw:
+            paths.append((t("settings.storage.whitelist"), Path(whitelist_raw)))
+        paths.append((t("settings.storage.preview_cache"), PREVIEW_CACHE_DIR))
+        # Nur auffuehren, wenn es sie gibt - sonst schickt der Tab den Anwender
+        # zu einer Datei, die nie angelegt wurde.
+        for key, name in (
+            ("settings.storage.crash", CRASH_LOG_NAME),
+            ("settings.storage.fault", "fault.log"),
+        ):
+            datei = SETTINGS_FILE.parent / name
+            if datei.is_file():
+                paths.append((t(key), datei))
+        return paths
+
+    def _int(self, selector: str, default: int, minimum: int = 1) -> int:
+        """Liest einen Integer-Wert aus einem Input-Feld (mit Fallback)."""
+        try:
+            return max(minimum, int(self.query_one(selector, Input).value))
+        except (ValueError, TypeError):
+            return default

console_error_scanner/screens/top_errors.py

@@ -0,0 +1,304 @@
+"""Modal-Screen fuer Top-10-Fehler Chart."""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Callable
+
+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, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+from ..i18n import t
+from ..models.scan_result import ErrorType, ScanResult
+
+# Maximale Laenge fuer Fehlermeldungen in der Anzeige
+MAX_MSG_LEN = 80
+# Breite des Balkens
+BAR_WIDTH = 40
+
+
+class TopErrorsScreen(ModalScreen):
+    """Modal-Dialog mit Top-10-Fehler als Balkendiagramm."""
+
+    DEFAULT_CSS = """
+    TopErrorsScreen {
+        align: center middle;
+    }
+
+    TopErrorsScreen > VerticalScroll {
+        width: 90%;
+        max-width: 120;
+        height: auto;
+        max-height: 90%;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+
+    TopErrorsScreen #top-title {
+        height: 3;
+        content-align: center middle;
+        text-style: bold;
+        background: $accent;
+        color: auto;
+        margin-bottom: 1;
+    }
+
+    TopErrorsScreen #top-content {
+        height: auto;
+    }
+
+    TopErrorsScreen #top-buttons {
+        height: 3;
+        align: center middle;
+        margin-top: 1;
+    }
+
+    TopErrorsScreen #top-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q", "close", "Close"),
+    ]
+
+    def __init__(self, results: list[ScanResult], **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._results = results
+
+    def _link(self, display: str, target: str) -> Text:
+        """Baut einen Hover-klickbaren Link-Text (volle URL als Klickziel).
+
+        Args:
+            display:
+                Der angezeigte (ggf. gekuerzte) Text.
+            target:
+                Die vollstaendige URL, die beim Klick geoeffnet wird.
+
+        Returns:
+            Ein ``Text`` mit ``@click``-Meta - oder unverlinkt, 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)
+
+    def compose(self) -> ComposeResult:
+        """Erstellt das Modal-Layout."""
+        with VerticalScroll():
+            yield Static(t("top_errors.title"), id="top-title")
+            yield Static(self._build_chart(), id="top-content")
+            with Horizontal(id="top-buttons"):
+                yield Button(t("binding.close"), variant="primary", id="top-close")
+
+    @on(Button.Pressed, "#top-close")
+    def _on_close_button(self) -> None:
+        self.dismiss()
+
+    def _build_chart(self) -> Text:
+        """Erstellt das Balkendiagramm der Top-10-Fehler.
+
+        Returns:
+            Formatierter Rich Text mit Balkendiagramm.
+        """
+        text = Text()
+
+        # Alle Fehler sammeln und nach Typ gruppieren
+        console_counter: Counter = Counter()
+        warning_counter: Counter = Counter()
+        http_404_counter: Counter = Counter()
+        http_4xx_counter: Counter = Counter()
+        http_5xx_counter: Counter = Counter()
+
+        for result in self._results:
+            for error in result.errors:
+                if error.whitelisted:
+                    continue
+                if error.error_type == ErrorType.CONSOLE_ERROR:
+                    msg = _normalize_message(error.message)
+                    console_counter[msg] += 1
+                elif error.error_type == ErrorType.CONSOLE_WARNING:
+                    msg = _normalize_message(error.message)
+                    warning_counter[msg] += 1
+                elif error.error_type == ErrorType.HTTP_404:
+                    http_404_counter[error.source or error.message] += 1
+                elif error.error_type == ErrorType.HTTP_4XX:
+                    http_4xx_counter[error.source or error.message] += 1
+                elif error.error_type == ErrorType.HTTP_5XX:
+                    http_5xx_counter[error.source or error.message] += 1
+
+        # Gesamtzaehler
+        total_errors = (
+            sum(console_counter.values())
+            + sum(warning_counter.values())
+            + sum(http_404_counter.values())
+            + sum(http_4xx_counter.values())
+            + sum(http_5xx_counter.values())
+        )
+
+        if total_errors == 0:
+            text.append(t("top_errors.no_errors"), style="green bold")
+            return text
+
+        text.append(t("top_errors.total", count=total_errors), style="bold")
+        pages_with_errors = sum(1 for r in self._results if r.has_issues)
+        text.append(f"{t('top_errors.pages', count=pages_with_errors)}\n", style="bold")
+        text.append("\n")
+
+        # === Console Errors Top 10 ===
+        if console_counter:
+            _append_section(text, "Console Errors", console_counter, "red")
+
+        # === Console Warnings Top 10 ===
+        if warning_counter:
+            _append_section(text, "Console Warnings", warning_counter, "yellow")
+
+        # === HTTP 404 Top 10 === (Eintraege sind URLs -> Hover-Links)
+        if http_404_counter:
+            _append_section(text, "HTTP 404", http_404_counter, "yellow", link_fn=self._link)
+
+        # === HTTP 4xx Top 10 ===
+        if http_4xx_counter:
+            _append_section(text, "HTTP 4xx", http_4xx_counter, "yellow", link_fn=self._link)
+
+        # === HTTP 5xx Top 10 ===
+        if http_5xx_counter:
+            _append_section(text, "HTTP 5xx", http_5xx_counter, "red", link_fn=self._link)
+
+        # === Seiten mit den meisten Fehlern ===
+        text.append("\u2500" * 60, style="dim")
+        text.append("\n\n")
+        text.append(f"{t('top_errors.most_errors')}\n", style="bold cyan underline")
+        text.append("\n")
+        page_errors = [(r.url, r.total_error_count) for r in self._results if r.has_issues]
+        page_errors.sort(key=lambda x: x[1], reverse=True)
+
+        if page_errors:
+            max_page_count = page_errors[0][1]
+            for rank, (url, count) in enumerate(page_errors[:10], 1):
+                label = self._link(_truncate(url, MAX_MSG_LEN), url)
+                _append_bar_entry(text, rank, label, count, max_page_count, "cyan")
+
+        return text
+
+    def action_close(self) -> None:
+        """Schliesst den Dialog."""
+        self.dismiss()
+
+
+def _append_section(
+    text: Text,
+    title: str,
+    counter: Counter,
+    color: str,
+    link_fn: Callable[[str, str], Text] | None = None,
+) -> None:
+    """Fuegt eine Chart-Sektion mit Balkendiagramm hinzu.
+
+    Args:
+        text: Rich Text zum Anhaengen.
+        title: Titel der Sektion.
+        counter: Counter mit Fehlermeldung -> Anzahl.
+        color: Farbe der Balken.
+        link_fn:
+            Optionaler Helfer (display, target) -> klickbarer Text. Gesetzt,
+            wenn die Counter-Keys URLs sind (HTTP-Sektionen) - dann wird das
+            Label ein Hover-Link mit der vollen URL als Klickziel.
+    """
+    text.append(f"{title}\n", style=f"bold {color} underline")
+    text.append("\n")
+
+    max_count = counter.most_common(1)[0][1] if counter else 1
+    for rank, (msg, count) in enumerate(counter.most_common(10), 1):
+        display = _truncate(msg, MAX_MSG_LEN)
+        label: str | Text = link_fn(display, msg) if link_fn else display
+        _append_bar_entry(text, rank, label, count, max_count, color)
+
+    text.append("\n")
+
+
+def _normalize_message(msg: str) -> str:
+    """Normalisiert eine Fehlermeldung fuer Gruppierung.
+
+    Entfernt variable Teile wie URLs mit Parametern, Timestamps etc.
+    Behaelt den Kerninhalt fuer die Gruppierung.
+
+    Args:
+        msg: Originale Fehlermeldung.
+
+    Returns:
+        Normalisierte Version.
+    """
+    if not msg:
+        return t("top_errors.empty")
+
+    # Erste Zeile nehmen
+    first_line = msg.split("\n")[0].strip()
+
+    # Sehr lange Meldungen kuerzen
+    if len(first_line) > 120:
+        first_line = f"{first_line[:117]}..."
+
+    return first_line
+
+
+def _truncate(text: str, max_len: int) -> str:
+    """Kuerzt einen Text auf maximale Laenge.
+
+    Args:
+        text: Der zu kuerzende Text.
+        max_len: Maximale Laenge.
+
+    Returns:
+        Gekuerzter Text.
+    """
+    if len(text) <= max_len:
+        return text
+    return f"{text[: max_len - 3]}..."
+
+
+def _append_bar_entry(
+    text: Text,
+    rank: int,
+    label: str | Text,
+    count: int,
+    max_count: int,
+    color: str,
+) -> None:
+    """Fuegt einen Chart-Eintrag hinzu (Label ueber Balken).
+
+    Layout:
+      1. Fehlermeldung hier...
+         ████████████████████████████ 15x
+
+    Args:
+        text: Rich Text zum Anhaengen.
+        rank: Rang-Nummer.
+        label: Beschreibungstext.
+        count: Anzahl.
+        max_count: Maximaler Wert (fuer Balkenbreite).
+        color: Farbe des Balkens.
+    """
+    # Zeile 1: Rang + Label (Label kann ein klickbarer Text sein)
+    text.append(f"  {rank:2d}. ", style="bold")
+    if isinstance(label, Text):
+        text.append_text(label)
+        text.append("\n")
+    else:
+        text.append(f"{label}\n", style="")
+
+    # Zeile 2: Eingerueckter Balken + Anzahl
+    bar_len = max(1, int(BAR_WIDTH * count / max_count)) if max_count > 0 else 1
+    bar = "\u2588" * bar_len
+    padding = " " * 6  # Einrueckung passend zum Label
+    text.append(f"{padding}{bar}", style=f"bold {color}")
+    text.append(f" {count}x\n", style="bold")