fxcss 0.22.0__tar.gz → 0.22.1__tar.gz

{fxcss-0.22.0 → fxcss-0.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fxcss
-Version: 0.22.0
+Version: 0.22.1
 Summary: Live-reload, inspect and screenshot-test Firefox userChrome.css themes
 Author: AdamXweb
 License: MIT
@@ -655,6 +655,17 @@ configuration file, it uses installed Stable, captures all optional
 stylesheets and fails on actionable selector findings. Visual comparison is
 enabled when you supply a baseline.
 
+The terminal shows the current phase and each accounted-for view, including
+views Firefox explicitly does not support, while the full details stay in the
+run logs. The report links directly to each captured screenshot and distinguishes
+a check with no visual baseline from one with advisory image changes. When
+comparing captures, it shows the baseline and current Firefox environments so
+you can spot version, OS, display-scale or window-size differences. If you
+interrupt a run, `check` still writes a report pointing to completed captures;
+views left unfinished are marked separately from failures. Rerun the
+command to finish. If interruption occurs during a baseline update, inspect
+the baseline directory before running another update.
+
 Save settings in `.fxcss.json` at the theme's root to use the same checks
 locally and in CI:
 
@@ -704,9 +715,9 @@ operating systems separate. `--firefox beta` overrides the list for one run.
 | `--config FILE` | Read a different JSON settings file. Command-line options override saved values. |
 
 Exit codes are **0** for completed checks within the configured policy,
-**1** for findings, and **2** for configuration, browser, capture or comparison
-errors. A configured baseline that is missing is an error, not an unchanged
-result. Invalid settings fail before Firefox is started.
+**1** for findings, and **2** for interruption or configuration, browser,
+capture or comparison errors. A configured baseline that is missing is an
+error, not an unchanged result. Invalid settings fail before Firefox is started.
 
 For a custom GitHub workflow with Firefox and a display already available,
 run `fxcss check` and upload `.fxcss/checks/` even when the check fails. Keep the

{fxcss-0.22.0 → fxcss-0.22.1}/README.md

@@ -632,6 +632,17 @@ configuration file, it uses installed Stable, captures all optional
 stylesheets and fails on actionable selector findings. Visual comparison is
 enabled when you supply a baseline.
 
+The terminal shows the current phase and each accounted-for view, including
+views Firefox explicitly does not support, while the full details stay in the
+run logs. The report links directly to each captured screenshot and distinguishes
+a check with no visual baseline from one with advisory image changes. When
+comparing captures, it shows the baseline and current Firefox environments so
+you can spot version, OS, display-scale or window-size differences. If you
+interrupt a run, `check` still writes a report pointing to completed captures;
+views left unfinished are marked separately from failures. Rerun the
+command to finish. If interruption occurs during a baseline update, inspect
+the baseline directory before running another update.
+
 Save settings in `.fxcss.json` at the theme's root to use the same checks
 locally and in CI:
 
@@ -681,9 +692,9 @@ operating systems separate. `--firefox beta` overrides the list for one run.
 | `--config FILE` | Read a different JSON settings file. Command-line options override saved values. |
 
 Exit codes are **0** for completed checks within the configured policy,
-**1** for findings, and **2** for configuration, browser, capture or comparison
-errors. A configured baseline that is missing is an error, not an unchanged
-result. Invalid settings fail before Firefox is started.
+**1** for findings, and **2** for interruption or configuration, browser,
+capture or comparison errors. A configured baseline that is missing is an
+error, not an unchanged result. Invalid settings fail before Firefox is started.
 
 For a custom GitHub workflow with Firefox and a display already available,
 run `fxcss check` and upload `.fxcss/checks/` even when the check fails. Keep the

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/__init__.py

@@ -1,3 +1,3 @@
 """fxcss — a testing toolkit for Firefox userChrome.css themes."""
 
-__version__ = "0.22.0"
+__version__ = "0.22.1"

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/capture.py

@@ -18,7 +18,8 @@ def expected_views(variants=(), modes=("light", "dark")):
             + [f"variant-{slug}" for slug in sorted(variants)])
 
 
-def write_coverage(directory, info, expected, unsupported=None, failed=None):
+def write_coverage(directory, info, expected, unsupported=None, failed=None,
+                   interrupted=False):
     unsupported, failed = unsupported or {}, failed or {}
     views = {}
     for name in expected:
@@ -28,6 +29,9 @@ def write_coverage(directory, info, expected, unsupported=None, failed=None):
             views[name] = {"status": "captured"}
         elif name in unsupported:
             views[name] = {"status": "unsupported", "reason": unsupported[name]}
+        elif interrupted:
+            views[name] = {"status": "not_completed",
+                           "reason": "capture stopped before this view completed"}
         else:
             views[name] = {"status": "failed", "reason": "expected view was not captured"}
     report = {"format": 1, "browser": info, "views": views}

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/check.py

@@ -6,10 +6,11 @@ import hashlib
 import json
 import math
 import shutil
+import sys
 import tempfile
 from pathlib import Path
 
-from . import capture, core, __version__
+from . import capture, compare, core, __version__
 from .fetch import VARIANT_DIRS
 
 
@@ -110,6 +111,93 @@ def comparison_status(summary, threshold):
     return 0
 
 
+class CaptureProgress:
+    """Keep the full capture log while showing completed views in the terminal."""
+
+    def __init__(self, log, terminal, total):
+        self.log, self.terminal, self.total = log, terminal, total
+        self.count = 0
+        self.pending = ""
+
+    def write(self, data):
+        written = self.log.write(data)
+        self.pending += data
+        while "\n" in self.pending:
+            line, self.pending = self.pending.split("\n", 1)
+            if line.startswith("  captured "):
+                self.count += 1
+                name = line.removeprefix("  captured ").split(".png", 1)[0]
+                print(f"  view {self.count}/{self.total}: {name} captured",
+                      file=self.terminal, flush=True)
+            elif line.startswith("  unsupported "):
+                self.count += 1
+                name, _, reason = line.removeprefix("  unsupported ").partition(": ")
+                print(f"  view {self.count}/{self.total}: {name} unsupported ({reason})",
+                      file=self.terminal, flush=True)
+            elif line.startswith(("  note:", "  warning:")):
+                print(line, file=self.terminal, flush=True)
+        return written
+
+    def flush(self):
+        self.log.flush()
+
+
+def read_coverage(path):
+    if not path.is_file():
+        return None
+    try:
+        report = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return report if isinstance(report, dict) and isinstance(report.get("views"), dict) else None
+
+
+def last_capture_error(path):
+    if not path.is_file():
+        return None
+    for line in reversed(path.read_text(encoding="utf-8", errors="replace").splitlines()):
+        if line.strip().startswith("error:"):
+            return line.strip().removeprefix("error:").strip()
+    return None
+
+
+def result_label(result):
+    if result.get("interrupted"):
+        return "interrupted"
+    status = result["exit_code"]
+    if status:
+        return ("findings", "error")[status - 1]
+    if result.get("comparison", {}).get("any_change"):
+        return "passed; visual changes to review"
+    if result.get("comparison_note") == "no baseline configured":
+        return "passed; visual comparison not run"
+    return "passed"
+
+
+def environment_label(info):
+    """Describe a capture with the fields that explain visual differences."""
+    if not isinstance(info, dict):
+        return "unknown environment"
+    label = f"Firefox {info.get('version', 'unknown')} on {info.get('os', 'unknown')}"
+    details = []
+    if info.get("dpr") is not None:
+        details.append(f"DPR {info['dpr']}")
+    outer = info.get("outer")
+    if isinstance(outer, (list, tuple)) and len(outer) == 2:
+        details.append(f"window {outer[0]}×{outer[1]}")
+    return label + (f" ({', '.join(details)})" if details else "")
+
+
+def environment_differences(baseline, current):
+    if not isinstance(baseline, dict) or not isinstance(current, dict):
+        return []
+    fields = (("version", "Firefox version"), ("os", "OS"),
+              ("dpr", "DPR"), ("outer", "window size"))
+    return [label for key, label in fields
+            if baseline.get(key) is not None and current.get(key) is not None
+            and baseline[key] != current[key]]
+
+
 BASELINE_MARKER = ".fxcss-baseline.json"
 
 
@@ -155,52 +243,119 @@ def update_baseline(baseline, captures):
 
 
 def write_report(directory, settings, results, status, baseline_updated):
+    interrupted = any(result.get("interrupted") for result in results)
     report = {
         "fxcss": __version__, "exit_code": status,
         "baseline_updated": baseline_updated,
+        "interrupted": interrupted,
         "settings": {k: str(v) if isinstance(v, Path) else v for k, v in settings.items()},
         "browsers": results,
     }
     (directory / "summary.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
-    lines = ["# Theme check", "", f"Result: **{('passed', 'findings', 'error')[status]}**", ""]
+    if interrupted:
+        overall = "interrupted"
+    elif status == 0 and any(r.get("comparison", {}).get("any_change") for r in results):
+        overall = "passed; visual changes to review"
+    elif status == 0 and baseline_updated:
+        overall = "passed; baseline updated"
+    elif status == 0 and settings["baseline"] is None:
+        overall = "passed; visual comparison not run"
+    else:
+        overall = ("passed", "findings", "error")[status]
+    lines = ["# Theme check", "", f"Result: **{overall}**", ""]
     for result in results:
         label = result["firefox"].replace("|", "\\|").replace("<", "&lt;")
-        lines += [f"## {label}", "", f"Result: **{('passed', 'findings', 'error')[result['exit_code']]}**", ""]
-        info = result.get("render_info", {})
-        if info:
-            lines += [f"Firefox {info.get('version', 'unknown')} on {info.get('os', 'unknown')}", ""]
+        lines += [f"## {label}", "", f"Result: **{result_label(result)}**", ""]
         key = result["key"]
+        audit_code = result.get("audit_exit_code")
+        audit_state = "not completed" if audit_code is None else ("passed", "findings", "error")[audit_code]
+        coverage = result.get("coverage", {}).get("views", {})
+        info = result.get("render_info") or result.get("coverage", {}).get("browser", {})
+        baseline_info = result.get("baseline_info")
+        if baseline_info is not None:
+            lines += [f"Baseline: {environment_label(baseline_info)}  ",
+                      f"Current: {environment_label(info)}", ""]
+            differences = environment_differences(baseline_info, info or {})
+            if differences:
+                lines += ["Capture environments differ in " + ", ".join(differences)
+                          + "; consider this when reviewing visual changes.", ""]
+        elif info:
+            lines += [environment_label(info), ""]
+        captured_count = sum(isinstance(v, dict) and v.get("status") == "captured"
+                             for v in coverage.values())
+        unfinished_count = sum(isinstance(v, dict) and v.get("status") == "not_completed"
+                               for v in coverage.values())
+        partial_counts = [f"{captured_count} captured"]
+        if unfinished_count:
+            partial_counts.append(f"{unfinished_count} unfinished")
+        capture_state = "complete" if result.get("captured") else (
+            f"partial ({', '.join(partial_counts)})"
+            if captured_count or unfinished_count else "not completed")
+        lines += [f"Selector audit: **{audit_state}**", "",
+                  f"Screenshot capture: **{capture_state}**", ""]
+        if result.get("error"):
+            lines += ["Error: " + result["error"].replace("<", "&lt;"), ""]
+        if unfinished_count:
+            lines += [f"{unfinished_count} views did not finish before the interruption.", ""]
         coverage_path = directory / key / "shots" / capture.REPORT
         if coverage_path.is_file():
             lines += [f"- [Screenshot coverage]({key}/shots/{capture.REPORT})"]
-        for name, view in result.get("coverage", {}).get("views", {}).items():
-            if view["status"] == "unsupported":
-                lines += [f"- Unsupported view `{name}`: {view['reason']}"]
+        for name, view in coverage.items():
+            if isinstance(view, dict) and view.get("status") in ("unsupported", "failed"):
+                lines += [f"- {view['status'].capitalize()} view `{name}`: "
+                          f"{view.get('reason', 'no reason recorded')}"]
         for name in ("audit.txt", "capture.txt", "comparison.txt"):
             if (directory / key / name).exists():
                 lines.append(f"- [{name}]({key}/{name})")
         if (directory / key / "fix.diff").exists():
             lines.append(f"- [Suggested selector patch]({key}/fix.diff)")
-        lines += [f"- [Browser captures]({key}/shots/)", ""] if result.get("captured") else []
+        image_paths = {path.stem: path for path in (directory / key / "shots").glob("*.png")}
+        images = [image_paths.pop(name) for name in coverage if name in image_paths]
+        images += sorted(image_paths.values())
+        if images:
+            partial = ", partial run" if not result.get("captured") else ""
+            lines += [f"Captured views ({len(images)}{partial}):", ""]
+            for path in images:
+                title, mode = compare.title_for(path.stem)
+                label = f"{title} ({mode})" if mode in ("light", "dark") else title
+                lines += [f"- [{label} (`{path.stem}`)]({key}/shots/{path.name})"]
+            lines.append("")
         if "comparison" in result:
             summary = result["comparison"]
-            lines += [f"Compared {len(summary['views'])} shared views; "
-                      f"{len(summary['changed_views'])} changed.", ""]
+            advisory = (summary["any_change"] and result["exit_code"] == 0)
+            note = " (advisory; no configured limit was exceeded)" if advisory else ""
+            lines += [f"Visual comparison: **{len(summary['changed_views'])} changed "
+                      f"of {len(summary['views'])} shared views{note}**.", ""]
             for heading, field in (("Added", "only_in_head"), ("Missing", "only_in_base")):
                 if summary[field]:
                     lines += [f"{heading} views: " + ", ".join(f"`{v}`" for v in summary[field]), ""]
             for view in summary["changed_views"]:
-                lines += [f"- [{view['view']}: {view['percent']:.3f}% changed]"
+                title = view.get("title") or view["view"]
+                lines += [f"- [{title} (`{view['view']}`): {view['percent']:.3f}% changed]"
                           f"({key}/diff/{view['image']})"]
             lines.append("")
         else:
-            lines += ["Visual comparison: " + result.get("comparison_note", "not completed") + ".", ""]
-        if result.get("error"):
-            lines += ["Error: " + result["error"].replace("<", "&lt;"), ""]
+            note = result.get("comparison_note", "not completed")
+            if note in ("no baseline configured", "baseline update requested"):
+                note = f"not run ({note})"
+            lines += ["Visual comparison: **" + note + "**.", ""]
     if baseline_updated:
         lines += ["Baseline updated from this run's captures.", ""]
     elif settings["baseline"]:
-        lines += ["The baseline was left unchanged. Use `--update-baseline` to accept a successful capture run.", ""]
+        if any(r.get("error") == "check interrupted during baseline update" for r in results):
+            lines += ["The baseline update was interrupted. Inspect the baseline directory "
+                      "before running another update.", ""]
+        elif interrupted:
+            lines += ["The baseline was left unchanged. Run `fxcss check` again to finish the check.", ""]
+        elif status == 2 and any("capture-coverage.json" in r.get("error", "")
+                                 and str(settings["baseline"]) in r.get("error", "")
+                                 for r in results):
+            lines += ["The baseline was left unchanged. Create it with "
+                      "`fxcss check --update-baseline` after reviewing these captures.", ""]
+        elif status:
+            lines += ["The baseline was left unchanged. Resolve the reported issue before updating it.", ""]
+        else:
+            lines += ["The baseline was left unchanged. Use `--update-baseline` to accept a successful capture run.", ""]
     (directory / "report.md").write_text("\n".join(lines), encoding="utf-8")
 
 
@@ -211,6 +366,8 @@ def run(args):
     settings["out"].mkdir(parents=True, exist_ok=True)
     directory = Path(tempfile.mkdtemp(prefix="run-", dir=settings["out"]))
     results, captures = [], {}
+    expected = capture.expected_views(core.parse_variant_spec(
+        settings["variants"], core.find_variant_sheets(theme)))
     for browser in settings["firefox"]:
         key = browser_key(browser)
         dest = directory / key
@@ -218,12 +375,15 @@ def run(args):
         result = {"firefox": browser, "key": key, "exit_code": 0}
         results.append(result)
         print(f"Checking {browser}…", flush=True)
+        phase = "browser setup"
         try:
             selected = browser
             if "/" in browser or "\\" in browser or browser.startswith("~"):
                 selected = str((theme / Path(browser).expanduser()).resolve())
             binary = core.find_firefox(selected)
             result["binary"] = str(binary)
+            phase = "selector audit"
+            print("  selector audit: running", flush=True)
             with (dest / "audit.txt").open("w", encoding="utf-8") as log:
                 with contextlib.redirect_stdout(log), contextlib.redirect_stderr(log):
                     result["audit_exit_code"] = cli.cmd_audit(argparse.Namespace(
@@ -231,20 +391,33 @@ def run(args):
                         no_colour=True, patch=dest / "fix.diff", strict=settings["strict"],
                         strict_vars=settings["strict_vars"]))
             result["exit_code"] = result["audit_exit_code"]
+            print(f"  selector audit: {('passed', 'findings', 'error')[result['audit_exit_code']]}",
+                  flush=True)
+            phase = "screenshot capture"
+            print(f"  screenshot capture: {len(expected)} views requested", flush=True)
             with (dest / "capture.txt").open("w", encoding="utf-8") as log:
-                with contextlib.redirect_stdout(log), contextlib.redirect_stderr(log):
+                progress = CaptureProgress(log, sys.stdout, len(expected))
+                with contextlib.redirect_stdout(progress), contextlib.redirect_stderr(log):
                     code = cli.cmd_shot(argparse.Namespace(
                         theme=theme, firefox=str(binary), out=dest / "shots", url=[],
                         only_live=False, variants=settings["variants"], toolbar=settings["toolbar"]))
+            coverage_path = dest / "shots" / capture.REPORT
+            available_coverage = read_coverage(coverage_path)
+            if available_coverage:
+                result["coverage"] = available_coverage
             if code:
-                if (dest / "shots" / capture.REPORT).is_file():
-                    capture.validate_coverage(dest / "shots", capture.expected_views(
-                        core.parse_variant_spec(settings["variants"], core.find_variant_sheets(theme))))
-                raise RuntimeError("capture failed; see capture.txt")
-            result["coverage"] = capture.validate_coverage(dest / "shots", capture.expected_views(
-                core.parse_variant_spec(settings["variants"], core.find_variant_sheets(theme))))
+                cause = last_capture_error(dest / "capture.txt")
+                raise RuntimeError("capture failed: " + (cause or "see capture.txt"))
+            result["coverage"] = capture.validate_coverage(dest / "shots", expected)
             compare._captures(dest / "shots")
             result["captured"] = True
+            view_states = [view["status"] for view in result["coverage"]["views"].values()]
+            captured_count = view_states.count("captured")
+            unsupported_count = view_states.count("unsupported")
+            summary = f"{len(view_states)}/{len(expected)} views accounted for; {captured_count} captured"
+            if unsupported_count:
+                summary += f", {unsupported_count} unsupported"
+            print(f"  screenshot capture: complete ({summary})", flush=True)
             info = dest / "shots/render-info.json"
             if info.exists():
                 result["render_info"] = json.loads(info.read_text(encoding="utf-8"))
@@ -255,7 +428,9 @@ def run(args):
             elif baseline is None:
                 result["comparison_note"] = "no baseline configured"
             else:
-                capture.validate_coverage(baseline / key)
+                phase = "visual comparison"
+                print("  visual comparison: running", flush=True)
+                result["baseline_info"] = capture.validate_coverage(baseline / key)["browser"]
                 with (dest / "comparison.txt").open("w", encoding="utf-8") as log:
                     with contextlib.redirect_stdout(log), contextlib.redirect_stderr(log):
                         code = compare.run(baseline / key, dest / "shots", dest / "diff", browser)
@@ -266,17 +441,31 @@ def run(args):
                 result["comparison"] = summary
                 result["exit_code"] = max(result["exit_code"], comparison_status(
                     summary, settings["max_changed_percent"]))
+                print(f"  visual comparison: {len(summary['changed_views'])} shared views changed",
+                      flush=True)
+        except KeyboardInterrupt:
+            available_coverage = read_coverage(dest / "shots" / capture.REPORT)
+            if available_coverage:
+                result["coverage"] = available_coverage
+            result.update(exit_code=2, interrupted=True,
+                          error=f"check interrupted during {phase}; completed files are retained")
         except (OSError, ValueError, RuntimeError, SystemExit) as exc:
             result.update(exit_code=2, error=str(exc))
-        print(f"  {browser}: {('passed', 'findings', 'error')[result['exit_code']]}", flush=True)
+        print(f"  {browser}: {result_label(result)}", flush=True)
         if result.get("error"):
             print(f"  {result['error']}", flush=True)
+        if result.get("interrupted"):
+            break
     status = max(r["exit_code"] for r in results)
     updated = False
     if args.update_baseline and status == 0:
         try:
             update_baseline(settings["baseline"], captures)
             updated = True
+        except KeyboardInterrupt:
+            status = 2
+            results[-1].update(exit_code=2, interrupted=True,
+                               error="check interrupted during baseline update")
         except (OSError, ValueError, RuntimeError) as exc:
             status = 2
             results[-1].update(exit_code=2, error=f"baseline update failed: {exc}")

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/compare.py

@@ -33,15 +33,19 @@ FRIENDLY_NAMES = {
     "01-window": "Browser window",
     "02-urlbar": "Address bar focused",
     "03-findbar": "Find bar",
+    "04-dialog": "Quit confirmation",
     "04-audio": "Tab playing audio",
     "05-muted": "Tab muted",
     "06-containers": "Container tabs",
     "07-many-tabs": "Tab strip overflowing",
     "08-private": "Private window",
     "09-compact": "Compact density",
-    "10-sidebar": "Sidebar open",
-    "11-rtl": "Right-to-left UI",
-    "12-customize": "Customize mode",
+    "10-sidebar-bookmarks": "Bookmarks sidebar",
+    "11-sidebar-history": "History sidebar",
+    "12-rtl": "Right-to-left UI",
+    "13-customize": "Customize mode",
+    "14-vertical-tabs": "Vertical tabs",
+    "15-toolbar": "Custom toolbar",
 }
 
 
@@ -155,8 +159,8 @@ def compare_view(name, base_path, head_path, outdir):
 
     comparison = stack(
         [
-            (("BEFORE  ·  base branch", (90, 96, 104)), base),
-            (("AFTER  ·  this PR", (32, 113, 62)), head),
+            (("BEFORE  ·  baseline", (90, 96, 104)), base),
+            (("AFTER  ·  current capture", (32, 113, 62)), head),
             ((f"CHANGED  ·  {pct:.2f}% of pixels", (176, 21, 92)), render_diff_panel(base, mask)),
         ],
         base.width,

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/complete.py

@@ -24,7 +24,8 @@ PATH_OPTIONS = frozenset({
     "--baseline", "--profile", "--config",
 })
 
-# Options taking a comma-separated list of the theme's optional stylesheets.
+# Options taking optional stylesheets; --variants/--combo also combine them
+# with '+', while commas separate captures.
 SHEET_OPTIONS = frozenset({"--with", "--variants", "--combo"})
 
 SHELLS = ("bash", "zsh", "fish")
@@ -114,6 +115,24 @@ def _comma_aware(current, candidates):
             if c.startswith(tail) and c not in chosen]
 
 
+def _combo_aware(current, candidates):
+    """Complete the last sheet in a combination, preserving earlier captures.
+
+    Sheets already in this combination are omitted, but may be reused in a
+    different comma-separated capture. Completed captures are not re-offered.
+    """
+    head, comma, pending = current.rpartition(",")
+    combo, plus, tail = pending.rpartition("+")
+    if not plus:
+        return _comma_aware(current, candidates)
+    chosen = set(combo.split("+"))
+    completed = set(head.split(","))
+    prefix = head + comma + combo + plus
+    return [prefix + c for c in candidates
+            if c.startswith(tail) and c not in chosen
+            and combo + plus + c not in completed]
+
+
 def candidates(words, cword, cwd=None):
     """Completion candidates for a command line.
 
@@ -132,7 +151,10 @@ def candidates(words, cword, cwd=None):
     if previous == "--firefox":
         return [c for c in channel_names() if c.startswith(current)]
     if previous in SHEET_OPTIONS:
-        return _comma_aware(current, sheet_names(words, cwd))
+        names = sheet_names(words, cwd)
+        if previous in ("--variants", "--combo"):
+            return _combo_aware(current, names)
+        return _comma_aware(current, names)
 
     command = next((w for w in words[1:cword] if not w.startswith("-")
                     and w in options), None)

{fxcss-0.22.0 → fxcss-0.22.1}/fxcss/core.py

@@ -458,15 +458,18 @@ class Session:
         self._window_ready = False
 
     def __enter__(self):
+        # Windows can connect Marionette before its first content process is
+        # ready. Give that process time, then try a fresh launch if it stalls.
+        attempts = 3 if sys.platform == "win32" else 2
         try:
-            for attempt in range(2):
+            for attempt in range(attempts):
                 self._start_browser()
                 try:
                     self._wait_for_initial_document()
                     return self
                 except BrowserStartupError as exc:
                     self._stop_browser()
-                    if attempt:
+                    if attempt == attempts - 1:
                         raise
                     print(f"  note: {exc}; restarting the temporary Firefox process",
                           flush=True)
@@ -517,11 +520,13 @@ class Session:
                     proc.kill()
                 proc.wait(timeout=5)
 
-    def _wait_for_initial_document(self, timeout=5):
+    def _wait_for_initial_document(self, timeout=None):
         # A Windows startup can leave every browser connected but without a
         # WindowGlobal or child process. Its chrome accepts commands, yet new
         # tabs never load. Detect this before adding fixture tabs so startup
         # can retry with a fresh process and the same prepared theme profile.
+        if timeout is None:
+            timeout = 20 if sys.platform == "win32" else 5
         deadline = time.monotonic() + timeout
         while True:
             state = self.m.script(INITIAL_DOCUMENT_STATE)
@@ -548,6 +553,7 @@ class Session:
         handle = Marionette._unwrap(self.m.command("WebDriver:GetWindowHandle"))
         self.m.command("WebDriver:SwitchToWindow", {"handle": handle})
         self._wait_for_fixture_pages()
+        self.m.async_script(FINALIZE_FIXTURE_LABELS)
         result = self.m.async_script(SEED_BOOKMARKS)
         if result is not True:
             print(f"  note: bookmark seeding returned {result!r}", flush=True)
@@ -703,6 +709,20 @@ const win = Services.wm.getMostRecentWindow("navigator:browser");
 return Array.from(win.gBrowser.tabs, tab => tab.linkedPanel);
 """
 
+FINALIZE_FIXTURE_LABELS = """
+const done = arguments[arguments.length - 1];
+const win = Services.wm.getMostRecentWindow("navigator:browser");
+win.document.l10n.ready.then(() => {
+  // A title set before pseudo-localisation changes document.dir keeps the
+  // earlier labelendaligned value until the title changes again.
+  for (const tab of win.gBrowser.tabs) {
+    tab.removeAttribute("label");
+    win.gBrowser.setTabTitle(tab);
+  }
+  done(true);
+});
+"""
+
 SETUP_TABS = """
 const [originalIds, pinned] = arguments;
 const win = Services.wm.getMostRecentWindow("navigator:browser");
@@ -1344,9 +1364,9 @@ def _dialog_shot(session: "Session", outdir: Path, name: str, timeout=45.0):
         print(f"  note: {name} timed out; skipping that view", flush=True)
         return
     if result.get("skip"):
-        print(f"  note: {result['skip']}; skipping {name}", flush=True)
         if result["skip"] == "no in-window modal prompts on this Firefox":
             return "no in-window modal prompts"
+        print(f"  note: {result['skip']}; skipping {name}", flush=True)
         return
     png = base64.b64decode(result["shot"].split(",", 1)[1])
     if len(png) < 2000:
@@ -1366,11 +1386,16 @@ def capture_views(session: Session, outdir: Path, modes=("light", "dark"),
         if path.stem in capture.expected_views() or capture.VARIANT.fullmatch(path.stem):
             path.unlink()
     coverage = {"info": {}, "unsupported": {}, "failed": {}}
+    interrupted = False
     try:
         info = _capture_views(session, outdir, modes, variants, toolbar, coverage)
+    except KeyboardInterrupt:
+        interrupted = True
+        raise
     finally:
         capture.write_coverage(outdir, coverage["info"], expected,
-                               coverage["unsupported"], coverage["failed"])
+                               coverage["unsupported"], coverage["failed"],
+                               interrupted=interrupted)
     capture.validate_coverage(outdir, expected)
     return info
 
@@ -1424,7 +1449,9 @@ def _capture_views(session: Session, outdir: Path, modes=("light", "dark"),
         # _shot -- no Marionette command may run while the dialog is up.
         unsupported = _dialog_shot(session, outdir, f"{mode}-04-dialog")
         if unsupported:
-            coverage["unsupported"][f"{mode}-04-dialog"] = unsupported
+            name = f"{mode}-04-dialog"
+            coverage["unsupported"][name] = unsupported
+            print(f"  unsupported {name}: {unsupported}", flush=True)
 
     # Extra chrome states, captured once rather than per colour scheme: each is
     # about a distinct piece of UI appearing, not about light versus dark.
@@ -1559,8 +1586,10 @@ def _capture_views(session: Session, outdir: Path, modes=("light", "dark"),
             version = re.match(r"\d+", str(info.get("version", "")))
             if version and int(version[0]) < 133:
                 coverage["unsupported"]["extra-14-vertical-tabs"] = "Firefox before 133"
-            print("  note: vertical tabs unavailable on this Firefox "
-                  "(needs 133+); skipping that view", flush=True)
+                print("  unsupported extra-14-vertical-tabs: Firefox before 133", flush=True)
+            else:
+                print("  note: vertical tabs unavailable on this Firefox "
+                      "(needs 133+); skipping that view", flush=True)
 
     with Session(session.repo, session.firefox) as tb:
         tb.setup_window()