mcward-cli 1.1.1__tar.gz → 1.2.0__tar.gz

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/.gitignore

@@ -23,6 +23,8 @@
 bin/
 build/
 classes/
+coverage.html
+coverage.lcov
 coverage.xml
 hs_err_*.log
 out/

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcward-cli
-Version: 1.1.1
+Version: 1.2.0
 Summary: Command-line interface for Ward, a testing framework for Minecraft datapacks using mcfunction.
 Author-email: Aksiome <54895777+aksiome@users.noreply.github.com>
 License: MPL-2.0

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/__init__.py

@@ -47,8 +47,7 @@ cli.add_command(test)
 
 def main() -> None:
     try:
-        # Click expands globs itself on Windows, which would consume -p patterns
-        # discover_datapacks resolves them instead
+        # discover_datapacks expands -p globs itself; Click's Windows expansion would eat them
         cli(windows_expand_args=False)
     except KeyboardInterrupt:
         console.print("\n[yellow]Interrupted[/yellow]")

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/commands/daemon.py

@@ -51,7 +51,7 @@ def stop(version: str | None, all: bool = False) -> None:
         print_warning(f"Version {env.version.name} is not running")
         return
 
-    envs = [cast(RunningEnvironment, manager.get(v.name)) for v in manager.list_running()]
+    envs = _running_environments()
     if not envs:
         print_note("No versions running")
         return
@@ -78,7 +78,7 @@ def stop(version: str | None, all: bool = False) -> None:
 @click.command()
 def status() -> None:
     """Show status of running daemons."""
-    envs = [cast(RunningEnvironment, manager.get(v.name)) for v in manager.list_running()]
+    envs = _running_environments()
     if not envs:
         print_note("No versions running")
         return
@@ -98,3 +98,7 @@ def status() -> None:
         table.add_row(env.version.name, str(env.process.pid), str(env.process.port), state)
 
     console.print("", table)
+
+
+def _running_environments() -> list[RunningEnvironment]:
+    return [cast(RunningEnvironment, manager.get(v.name)) for v in manager.list_running()]

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/commands/test.py

@@ -1,14 +1,16 @@
 """The test command."""
 
 import sys
+from pathlib import Path
 
 import rich_click as click
 
-from mcward import WardError
+from mcward import CoverageIgnores, WardError
 
 from ..datapacks import DEFAULT_PATTERNS, discover_datapacks
 from ..environments import manager, select_compatible, start_environments
 from ..reporters import github, live
+from ..reports import parse_coverage_report, report_session
 from ..ui import console
 
 
@@ -33,11 +35,39 @@ from ..ui import console
     default="live",
     help="Result output: interactive live display, or GitHub Actions annotations",
 )
+@click.option(
+    "--coverage",
+    is_flag=True,
+    help="Record which function commands run and report line coverage",
+)
+@click.option(
+    "--coverage-report",
+    "coverage_reports",
+    multiple=True,
+    metavar="FORMAT[:PATH]",
+    help="Write coverage as 'lcov' or 'html', with an optional path (repeatable); "
+    "implies --coverage",
+)
+@click.option(
+    "--junit-xml",
+    type=click.Path(dir_okay=False, writable=True, path_type=Path),
+    default=None,
+    help="Write test results as JUnit XML",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    help="List every test and coverage row instead of collapsing large runs",
+)
 @click.argument("selector", default="*:*")
 def test(
     versions: tuple[str, ...],
     packs: tuple[str, ...],
     reporter: str,
+    coverage: bool,
+    coverage_reports: tuple[str, ...],
+    junit_xml: Path | None,
+    verbose: bool,
     selector: str,
 ) -> None:
     """Run datapack tests."""
@@ -56,11 +86,15 @@ def test(
     selected = versions or select_compatible(strictest.min_format, loosest.max_format)
     paths = [datapack.path for datapack in datapacks]
 
+    specs = [parse_coverage_report(value) for value in coverage_reports]
+    enabled = coverage or bool(specs)
     run = github.run if reporter == "github" else live.run
     try:
+        ignores = CoverageIgnores.load()
         envs = start_environments([manager.get(v) for v in selected])
         console.print()
-        session = run(paths, envs, selector)
+        session = run(paths, envs, selector, coverage=enabled, verbose=verbose)
+        report_session(session, paths, specs, junit_xml, verbose, selector, ignores)
         if session.failed:
             sys.exit(1)
     except WardError as e:

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/datapacks.py

@@ -1,5 +1,6 @@
 """Datapack discovery, pack.mcmeta parsing and resource-to-file resolution."""
 
+import glob
 import json
 import os
 import zipfile
@@ -26,14 +27,14 @@ class DataPack:
 
 def discover_datapacks(patterns: Sequence[str]) -> list[DataPack]:
     """Find the datapacks (directories or zips) matching the glob patterns."""
-    cwd = Path.cwd()
     paths = set()
 
     for pattern in patterns:
         if (p := Path(pattern)).exists():
             paths.add(p.resolve())
         else:
-            paths.update(p.resolve() for p in cwd.glob(pattern))
+            matches = glob.glob(pattern, recursive=True, include_hidden=True)
+            paths.update(Path(m).resolve() for m in matches)
 
     return [parse_datapack(p) for p in paths if _is_datapack(p)]
 

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/environments.py

@@ -5,7 +5,6 @@ from concurrent.futures import ThreadPoolExecutor
 from itertools import groupby
 
 import rich_click as click
-from questionary.prompts.common import Choice
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from mcward import (
@@ -18,7 +17,7 @@ from mcward import (
     VersionNotFoundError,
 )
 
-from .ui import console, print_note, print_success, select
+from .ui import Option, console, print_note, print_success, select
 
 manager = EnvironmentManager()
 
@@ -27,12 +26,12 @@ def curate_versions(versions: Iterable[Version]) -> list[Version]:
     """Keep all releases but only the newest snapshot of each (year, major) line."""
     seen = set()
     curated = []
-    for v in versions:
-        k = (v.year, v.major)
-        if v.is_snapshot and k in seen:
+    for version in versions:
+        line = (version.year, version.major)
+        if version.is_snapshot and line in seen:
             continue
-        curated.append(v)
-        seen.add(k)
+        curated.append(version)
+        seen.add(line)
     return curated
 
 
@@ -45,18 +44,12 @@ def get_environment(version: str) -> Environment:
 
 def select_installed(message: str) -> str:
     """Prompt for an installed version, skipping the prompt when only one fits."""
-    versions = manager.list_installed()
-    if not versions:
-        raise click.ClickException("No versions installed")
-    return versions[0].name if len(versions) == 1 else select(message, [v.name for v in versions])
+    return _select_version(manager.list_installed(), message, "No versions installed")
 
 
 def select_running(message: str) -> str:
     """Prompt for a running version, skipping the prompt when only one fits."""
-    versions = manager.list_running()
-    if not versions:
-        raise click.ClickException("No versions running")
-    return versions[0].name if len(versions) == 1 else select(message, [v.name for v in versions])
+    return _select_version(manager.list_running(), message, "No versions running")
 
 
 def select_available(message: str) -> str:
@@ -65,18 +58,13 @@ def select_available(message: str) -> str:
     if not curated:
         raise click.ClickException("No versions available")
 
-    choices = []
     snapshot = next((v for v in curated if v.is_snapshot), None)
     latest = next((v for v in curated if not v.is_snapshot), None)
-    for v in curated:
-        title = [("", v.name)]
-        if v == latest:
-            title.append(("dim", " (latest)"))
-        elif v == snapshot:
-            title.append(("dim", " (snapshot)"))
-        choices.append(Choice(title))
-
-    return select(message, choices)
+    options = []
+    for version in curated:
+        hint = "(latest)" if version == latest else "(snapshot)" if version == snapshot else ""
+        options.append(Option(version.name, hint))
+    return select(message, options)
 
 
 def select_compatible(min_format: int, max_format: int) -> list[str]:
@@ -92,10 +80,9 @@ def select_compatible(min_format: int, max_format: int) -> list[str]:
         return [versions[0].name]
 
     print_note("Pack format range supports multiple major versions")
-
-    choices = [Choice(title=[("", "Use all versions "), ("dim", "(Recommended)")], value="all")]
-    choices.extend(Choice(title=f"Use {v.name} only", value=v.name) for v in versions)
-    name = select("Select version strategy:", choices)
+    options = [Option("Use all versions", "(Recommended)", value="all")]
+    options.extend(Option(f"Use {v.name} only", value=v.name) for v in versions)
+    name = select("Select version strategy:", options)
 
     return [v.name for v in versions if name == "all" or v.name == name]
 
@@ -112,6 +99,14 @@ def start_environments(envs: Sequence[Environment]) -> list[RunningEnvironment]:
             return list(executor.map(lambda env: _start_environment(env, progress), envs))
 
 
+def _select_version(versions: list[Version], message: str, empty: str) -> str:
+    if not versions:
+        raise click.ClickException(empty)
+    if len(versions) == 1:
+        return versions[0].name
+    return select(message, [v.name for v in versions])
+
+
 def _start_environment(env: Environment, progress: Progress) -> RunningEnvironment:
     """Start a single environment, reporting steps to the shared progress."""
     if isinstance(env, UninstalledEnvironment):

mcward_cli-1.2.0/src/mcward/cli/reporters/coverage.py

@@ -0,0 +1,159 @@
+"""Coverage rendering shared by the terminal reporters."""
+
+from collections.abc import Callable, Mapping, Sequence
+
+from rich.text import Text
+
+from mcward import (
+    CoverageReport,
+    CoverageTotals,
+    FunctionReport,
+    ResolvedCoverage,
+    ResourceReport,
+    Version,
+)
+
+_GAP_PATHS_SHOWN = 3
+
+
+def render_coverage(resolved: Mapping[Version, ResolvedCoverage], verbose: bool = False) -> Text:
+    """The coverage summary, one section per version that reported it."""
+    text = Text()
+    for version, coverage in resolved.items():
+        reports = coverage.reports
+        if len(resolved) > 1:
+            text.append(f"{version.name}\n", "magenta")
+        _render_summary(text, reports)
+        _render_groups(text, reports)
+        if verbose:
+            _render_gaps(text, coverage.functions)
+            _render_uncalled(text, coverage.functions)
+            _render_condition_gaps(text, coverage.resources)
+    return text
+
+
+def _render_summary(text: Text, reports: Sequence[CoverageReport]) -> None:
+    totals = CoverageTotals.of(reports)
+    text.append("Coverage: ", "bold")
+    text.append(_share(totals))
+    text.append(
+        f" ({totals.covered}/{totals.total}, {totals.touched}/{totals.files} files)\n", "dim"
+    )
+
+
+def _render_groups(text: Text, reports: Sequence[CoverageReport]) -> None:
+    """One rollup row per group: combined share, covered count, files reached."""
+    key = _group_key(reports)
+    groups = sorted({key(report) for report in reports})
+    if len(groups) < 2:
+        return
+
+    rows = []
+    for group in groups:
+        totals = CoverageTotals.of(report for report in reports if key(report) == group)
+        counts = f"{totals.covered}/{totals.total}"
+        rows.append((group, _share(totals, 6), counts, f"{totals.touched}/{totals.files} files"))
+
+    name_width = max(len(row[0]) for row in rows)
+    count_width = max(len(row[2]) for row in rows)
+    for group, share, counts, files in rows:
+        text.append(f"  {group:<{name_width}}  {share}")
+        text.append(f"  {counts:>{count_width}}", "dim")
+        text.append(f"  {files}\n", "dim")
+
+
+def _share(totals: CoverageTotals, width: int = 0) -> str:
+    return f"{totals.ratio:{width}.1%}" if totals.ratio is not None else f"{'—':>{width}}"
+
+
+def _group_key(reports: Sequence[CoverageReport]) -> Callable[[CoverageReport], str]:
+    """Group by namespace, or by resource type when there is only one."""
+    if len({report.namespace for report in reports}) > 1:
+        return lambda report: report.namespace
+    return lambda report: report.kind
+
+
+def _render_gaps(text: Text, reports: Sequence[FunctionReport]) -> None:
+    gaps = [r for r in reports if r.touched and r.covered < r.total]
+    gaps.sort(key=lambda r: (r.covered - r.total, r.name))
+
+    for report in gaps:
+        text.append("  ~ ", "yellow")
+        text.append(report.name)
+        text.append(f" {report.covered}/{report.total}", "dim")
+        if detail := _describe_gaps(report):
+            text.append(f"  {detail}", "dim yellow")
+        text.append("\n")
+
+
+def _render_condition_gaps(text: Text, resources: Sequence[ResourceReport]) -> None:
+    """An untouched file gets counts only: paths would drown big generated files."""
+    gaps = [r for r in resources if r.covered < r.total]
+    gaps.sort(key=lambda r: (r.covered - r.total, r.name))
+
+    for resource in gaps:
+        symbol, style = ("~", "yellow") if resource.touched else ("✗", "red")
+        text.append(f"  {symbol} ", style)
+        text.append(resource.name)
+        text.append(f" ({resource.kind})", "dim")
+        text.append(f" {resource.covered}/{resource.total}", "dim")
+        if resource.touched and (detail := _describe_nodes(resource)):
+            text.append(f"  {detail}", "dim yellow")
+        text.append("\n")
+
+
+def _describe_nodes(resource: ResourceReport) -> str:
+    groups: dict[str, list[str]] = {"never": [], "blocked": [], "unreached": []}
+    for node in resource.counted:
+        if not node.evaluated:
+            groups["never"].append(node.path)
+    for run in resource.runs:
+        if run.blocked:
+            groups["blocked"].append(run.path)
+        elif not run.reached:
+            groups["unreached"].append(run.path)
+    return "; ".join(f"{label} {_some_paths(paths)}" for label, paths in groups.items() if paths)
+
+
+def _some_paths(paths: list[str]) -> str:
+    shown = ", ".join(path or "(root)" for path in paths[:_GAP_PATHS_SHOWN])
+    extra = len(paths) - _GAP_PATHS_SHOWN
+    return f"{shown} +{extra} more" if extra > 0 else shown
+
+
+def _render_uncalled(text: Text, reports: Sequence[FunctionReport]) -> None:
+    for report in reports:
+        if report.lines and not report.touched:
+            text.append("  ✗ ", "red")
+            text.append(report.name)
+            text.append(f" 0/{report.total}\n", "dim")
+
+
+def _describe_gaps(report: FunctionReport) -> str:
+    if report.file is None:
+        return ""
+    unreached = [line.line for line in report.lines if not line.reached and line.line is not None]
+    guarded = [line.line for line in report.guarded if line.line is not None]
+    parts = []
+    if unreached:
+        parts.append(f"missing {_ranges(unreached)}")
+    if guarded:
+        parts.append(f"guarded {_ranges(guarded)}")
+    return "; ".join(parts)
+
+
+def _ranges(lines: Sequence[int]) -> str:
+    """Consecutive line numbers folded into ranges: 5-6, 10."""
+
+    def fold(start: int, end: int) -> str:
+        return str(start) if start == end else f"{start}-{end}"
+
+    parts: list[str] = []
+    start = previous = lines[0]
+    for line in lines[1:]:
+        if line != previous + 1:
+            parts.append(fold(start, previous))
+            start = line
+        previous = line
+    parts.append(fold(start, previous))
+    return ", ".join(parts)

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/reporters/github.py

@@ -22,6 +22,8 @@ def run(
     datapacks: Sequence[Path],
     environments: Sequence[RunningEnvironment],
     selector: str = "*:*",
+    coverage: bool = False,
+    verbose: bool = False,
     resolve: FileResolver | None = None,
 ) -> TestSession:
     """Run tests, printing the final results view and GitHub annotations."""
@@ -30,8 +32,8 @@ def run(
     resolve = resolve or pack_resolver(datapacks)
 
     # Consume the stream without rendering; it always yields a starting frame
-    *_, session = run_tests(datapacks, environments, selector=selector)
-    console.print(render_session(session, resolve))
+    *_, session = run_tests(datapacks, environments, selector=selector, coverage=coverage)
+    console.print(render_session(session, resolve, verbose))
 
     for command in annotations(session, resolve):
         print(command, flush=True)

{mcward_cli-1.1.1 → mcward_cli-1.2.0}/src/mcward/cli/reporters/live.py

@@ -2,12 +2,14 @@
 
 from collections.abc import Sequence
 from pathlib import Path
+from time import monotonic
 
 from rich.live import Live
 from rich.text import Text
 
 from mcward import (
     RunningEnvironment,
+    TestBatch,
     TestResult,
     TestSession,
     TestStatus,
@@ -38,6 +40,8 @@ def run(
     datapacks: Sequence[Path],
     environments: Sequence[RunningEnvironment],
     selector: str = "*:*",
+    coverage: bool = False,
+    verbose: bool = False,
     resolve: FileResolver | None = None,
 ) -> TestSession:
     """Run tests across running environments with a live Rich display."""
@@ -45,10 +49,16 @@ def run(
     console.print(render_header([p.name for p in datapacks], versions))
     resolve = resolve or pack_resolver(datapacks)
 
-    session = TestSession(versions)  # placeholder so the return is always bound
+    session = TestSession(versions)  # rebound by every frame; bound even if none arrives
+    rendered = 0.0
     with Live(console=console, refresh_per_second=10) as live:
-        for session in run_tests(datapacks, environments, selector=selector):
-            live.update(render_session(session, resolve), refresh=False)
+        for session in run_tests(datapacks, environments, selector=selector, coverage=coverage):
+            # Events can outpace the display many times over; render at frame rate
+            if (now := monotonic()) - rendered < 0.1:
+                continue
+            rendered = now
+            live.update(render_session(session, resolve, verbose), refresh=False)
+        live.update(render_session(session, resolve, verbose), refresh=False)
     return session
 
 
@@ -58,10 +68,7 @@ def format_millis(millis: int) -> str:
 
 
 def describe_failure(outcome: VersionOutcome, file: str | None = None) -> str:
-    """The failure message, with the position suffix when the test carries one.
-
-    With a ``path:line`` relative to the project root when applicable.
-    """
+    """The failure message, with its position (``file:line`` when the file is known) and tick."""
     if outcome.line is None:
         return outcome.error
     if file is None:
@@ -81,20 +88,34 @@ def render_header(datapacks: Sequence[str], versions: Sequence[Version]) -> Text
     return text
 
 
-def render_session(session: TestSession, resolve: FileResolver | None = None) -> Text:
+def render_session(
+    session: TestSession,
+    resolve: FileResolver | None = None,
+    verbose: bool = False,
+) -> Text:
     """The full aggregated results view for the test phase."""
     text = Text()
+    batches = session.batches
+    summary = session.summary
     _render_diagnostics(text, session, resolve)
-    for batch in session.batches:
-        label = f"{batch.name} ({batch.dimension})" if batch.dimension else batch.name
-        text.append(f"\n {label}\n", "dim")
-        for result in batch.results:
-            _render_result(text, result, resolve)
+    if not verbose and batches:
+        text.append("\n")
+        active = session.active_batches if not summary.done else set()
+        width = max(len(batch.name) for batch in batches)
+        counts = [_count(batch) for batch in batches]
+        count_width = max(map(len, counts))
+        for batch, count in zip(batches, counts, strict=True):
+            _render_batch(text, batch, active, width, f"{count:>{count_width}}", resolve)
+    else:
+        for batch in batches:
+            text.append(f"\n {_label(batch)}\n", "dim")
+            for result in batch.results:
+                _render_result(text, result, resolve)
 
     for version, message in session.aborted.items():
         text.append(f"✗ {version.name}: {message}\n", "red")
     text.append("\n")
-    _render_summary(text, session.summary, session.versions)
+    _render_summary(text, summary, session.versions)
     return text
 
 
@@ -123,10 +144,57 @@ def _render_diagnostics(
         text.append(f"  {diagnostic.message}\n", f"dim {style}")
 
 
+def _render_batch(
+    text: Text,
+    batch: TestBatch,
+    active: set[tuple[str, str | None]],
+    width: int,
+    count: str,
+    resolve: FileResolver | None = None,
+) -> None:
+    """One line per batch: status symbol, name, dimension, aligned passed count."""
+    statuses = [result.status for result in batch.results]
+    if TestStatus.FAILED in statuses:
+        status: TestStatus | None = TestStatus.FAILED
+    elif None in statuses or (batch.name, batch.dimension) in active:
+        status = None
+    elif TestStatus.SKIPPED in statuses:
+        status = TestStatus.SKIPPED
+    else:
+        status = TestStatus.PASSED
+
+    symbol, style = _SYMBOL[status]
+    text.append(f"{_frame(symbol)} ", style)
+    text.append(f"{batch.name:<{width}}")
+    text.append(f" {count}")
+    if batch.dimension:
+        text.append(f" ({batch.dimension})", "dim")
+    text.append("\n")
+
+    for result in batch.results:
+        if result.status in (TestStatus.FAILED, TestStatus.SKIPPED):
+            _render_result(text, result, resolve)
+
+
+def _label(batch: TestBatch) -> str:
+    return f"{batch.name} ({batch.dimension})" if batch.dimension else batch.name
+
+
+def _count(batch: TestBatch) -> str:
+    """Passed over the announced batch size, so the denominator is stable mid-run."""
+    passed = sum(result.status is TestStatus.PASSED for result in batch.results)
+    return f"{passed}/{max(batch.total or 0, len(batch.results))}"
+
+
+def _frame(symbol: str | tuple[str, ...]) -> str:
+    if isinstance(symbol, tuple):
+        return symbol[(int(console.get_time() * 16 % len(symbol)))]
+    return symbol
+
+
 def _render_result(text: Text, result: TestResult, resolve: FileResolver | None = None) -> None:
     symbol, symbol_style = _SYMBOL[result.status]
-    if isinstance(symbol, tuple):
-        symbol = symbol[(int(console.get_time() * 16 % len(symbol)))]
+    symbol = _frame(symbol)
 
     text.append("  ")
     text.append(f"{symbol} ", symbol_style)
@@ -176,7 +244,11 @@ def _render_failure(
 
 def _render_summary(text: Text, summary: TestSummary, versions: tuple[Version, ...]) -> None:
     if not summary.done:
-        text.append(f"Tests: {summary.completed}/{summary.total} completed", "dim")
+        if summary.total:
+            text.append(f"Tests: {summary.completed}/{summary.total} completed", "dim")
+        else:
+            # Nothing has been announced yet: the server is still deploying and booting
+            text.append("Starting tests…", "dim")
         return
 
     if len(versions) > 1: