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

{mcward_cli-1.1.0 → 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.0 → mcward_cli-1.2.0}/PKG-INFO

@@ -1,7 +1,7 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: mcward-cli
-Version: 1.1.0
-Summary: Command-line interface for Ward - A testing framework for Minecraft datapacks using mcfunction.
+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
 Requires-Python: >=3.14

{mcward_cli-1.1.0 → mcward_cli-1.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "mcward-cli"
 dynamic = ["version"]
-description = "Command-line interface for Ward - A testing framework for Minecraft datapacks using mcfunction."
+description = "Command-line interface for Ward, a testing framework for Minecraft datapacks using mcfunction."
 readme = "README.md"
 requires-python = ">=3.14"
 license = { text = "MPL-2.0" }

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

@@ -15,18 +15,12 @@ class DefaultCommandGroup(click.RichGroup):
     """Click group that routes to the test command by default."""
 
     def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
-        """Parse args, routing to the test command if no subcommand is specified."""
         if not args or self._is_test_invocation(args[0]):
             return super().parse_args(ctx, ["test"] + args)
         return super().parse_args(ctx, args)
 
     def _is_test_invocation(self, arg: str) -> bool:
-        """Check whether the first arg is meant for test rather than a subcommand.
-
-        Only selectors (namespaced ids, wildcards) and options default to test;
-        a bare word that matches no command is left to click so typos produce
-        "No such command" instead of silently running zero tests.
-        """
+        """Whether the first argument is meant for test rather than a subcommand."""
         if arg in self.commands or arg in ("-h", "--help"):
             return False
         return arg.startswith("-") or ":" in arg or "*" in arg
@@ -52,10 +46,8 @@ cli.add_command(test)
 
 
 def main() -> None:
-    """Entry point for the CLI."""
     try:
-        # Click's Windows glob pre-expansion would resolve -p patterns before
-        # discover_datapacks gets them; patterns are resolved by ward itself
+        # 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.0 → mcward_cli-1.2.0}/src/mcward/cli/commands/daemon.py

@@ -1,4 +1,4 @@
-"""Daemon commands - start, stop, and status."""
+"""The start, stop and status commands."""
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import cast
@@ -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.0 → mcward_cli-1.2.0}/src/mcward/cli/commands/install.py

@@ -1,4 +1,4 @@
-"""Install and clean commands - version management."""
+"""The install and clean commands."""
 
 import rich_click as click
 

{mcward_cli-1.1.0 → mcward_cli-1.2.0}/src/mcward/cli/commands/list.py

@@ -1,4 +1,4 @@
-"""List command - show available and installed versions."""
+"""The list command."""
 
 import rich_click as click
 
@@ -21,7 +21,6 @@ def list_versions(ctx: click.Context, remote: bool) -> None:
 
 
 def _print_installed(installed: list[Version], command_path: str) -> None:
-    """Print the locally installed versions."""
     console.print("\n[bold]Installed Versions[/]:")
     if not installed:
         console.print("  [dim]No versions installed[/dim]")
@@ -71,6 +70,5 @@ def _print_version(
     color: str = "green",
     label: str = "",
 ) -> None:
-    """Print a version entry to the console."""
     label = f" [dim]({label})[/]" if label else ""
     console.print(f"  [bold {color}]{marker}[/] {version.name}{label}", highlight=False)

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

@@ -1,14 +1,16 @@
-"""Test command - run datapack tests."""
+"""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.0 → 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
@@ -19,23 +20,21 @@ MCFUNCTION_FOLDERS = ("test", "function")
 
 @dataclass(frozen=True)
 class DataPack:
-    """Datapack with its pack format range."""
-
     path: Path
     min_format: int
     max_format: int
 
 
 def discover_datapacks(patterns: Sequence[str]) -> list[DataPack]:
-    """Discover datapacks — directories or zips — from glob patterns."""
-    cwd = Path.cwd()
+    """Find the datapacks (directories or zips) matching the glob patterns."""
     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.0 → 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,66 +26,49 @@ 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
 
 
-def get_environment(version: Version | str) -> Environment:
-    """Get the environment for the given version."""
-    return get_environments([version])[0]
-
-
-def get_environments(versions: Sequence[Version | str]) -> list[Environment]:
-    """Get environments for the given versions."""
+def get_environment(version: str) -> Environment:
     try:
-        return [manager.get(v if isinstance(v, str) else v.name) for v in versions]
+        return manager.get(version)
     except VersionNotFoundError as e:
         raise click.ClickException(str(e)) from e
 
 
 def select_installed(message: str) -> str:
-    """Select an installed version."""
-    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])
+    """Prompt for an installed version, skipping the prompt when only one fits."""
+    return _select_version(manager.list_installed(), message, "No versions installed")
 
 
 def select_running(message: str) -> str:
-    """Select a running version."""
-    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])
+    """Prompt for a running version, skipping the prompt when only one fits."""
+    return _select_version(manager.list_running(), message, "No versions running")
 
 
 def select_available(message: str) -> str:
-    """Select an available version."""
+    """Prompt for a version to install, flagging the latest and the snapshot."""
     curated = curate_versions(manager.list_available())
     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]:
-    """Resolve which versions to test based on pack format range."""
+    """The versions to test, one per major line, asking when several qualify."""
     compatible = manager.list_compatible(min_format, max_format)
     if not compatible:
         err = f"No compatible versions found for pack format range {min_format}..{max_format}"
@@ -98,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]
 
@@ -118,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/__init__.py

@@ -0,0 +1,5 @@
+"""Reporters present a test run: each module exposes the same ``run()``."""
+
+from . import github, live
+
+__all__ = ["github", "live"]

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.0 → 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)