prodc 0.3.1__tar.gz → 0.3.3__tar.gz

{prodc-0.3.1 → prodc-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prodc
-Version: 0.3.1
+Version: 0.3.3
 Summary: Product management as code: personas, flows, and features traced to evidence.
 Project-URL: Homepage, https://gitlab.com/jorgeecardona/prodc
 Project-URL: Repository, https://gitlab.com/jorgeecardona/prodc

{prodc-0.3.1 → prodc-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prodc"
-version = "0.3.1"
+version = "0.3.3"
 description = "Product management as code: personas, flows, and features traced to evidence."
 readme = "README.md"
 requires-python = ">=3.12"

{prodc-0.3.1 → prodc-0.3.3}/src/prodc/adapters.py

@@ -201,13 +201,21 @@ class PytestAdapter:
         return out
 
     def resolve(self, payload: str) -> ProofResult:
-        file_part, _, node = payload.partition("::")
-        func = node.split("[")[0]  # strip parametrisation
+        # Node id: file[::Class[::Nested]]::test_name, each segment may carry [params].
+        parts = [p.split("[")[0] for p in payload.split("::")]
+        file_part = parts[0]
+        node = parts[1:]
+        func = node[-1] if node else ""
+        classes = node[:-1]  # class path for class-based tests (file::TestX::test_y)
         fp = self._root / file_part
         if not fp.exists():
             return ProofResult(ProofState.BROKEN, False, f"no file '{file_part}'")
-        if func and f"def {func}" not in fp.read_text(encoding="utf-8"):
-            return ProofResult(ProofState.BROKEN, False, f"no test '{func}' in {file_part}")
+        text = fp.read_text(encoding="utf-8")
+        missing = [f"class {c}" for c in classes if f"class {c}" not in text]
+        if func and f"def {func}" not in text:
+            missing.append(f"def {func}")
+        if missing:
+            return ProofResult(ProofState.BROKEN, False, f"no {', '.join(missing)} in {file_part}")
         results = self._load_results()
         if func in results:
             ok = results[func]
@@ -217,3 +225,21 @@ class PytestAdapter:
                 "junit: passed" if ok else "junit: failing",
             )
         return ProofResult(ProofState.DELIVERED, True, "test exists")
+
+
+class FilesAdapter:
+    """Resolves ``path`` to a verification script's existence.
+
+    For proofs that are executable models/scripts, not pytest tests. Existence is a
+    *declared* DELIVERED — a script existing is not a script passing; a run/result
+    marker (confirmed) is left for later, mirroring the gherkin/pytest results split.
+    """
+
+    def __init__(self, root: Path) -> None:
+        self._root = root
+
+    def resolve(self, payload: str) -> ProofResult:
+        fp = self._root / payload
+        if not fp.exists():
+            return ProofResult(ProofState.BROKEN, False, f"no file '{payload}'")
+        return ProofResult(ProofState.DELIVERED, True, "script exists")

{prodc-0.3.1 → prodc-0.3.3}/src/prodc/cli.py

@@ -168,17 +168,25 @@ def _to_json(results: list[NeedResult], summary: Summary, orphan_map: dict[str,
     return json.dumps(payload, indent=2)
 
 
-def _cmd_status(args: argparse.Namespace) -> int:
+def _load_or_report(args: argparse.Namespace) -> tuple[Config, list[Need]] | None:
+    """Load config + needs, or print the error to stderr and return None."""
     cfg_path = Path(args.config)
     if not cfg_path.exists():
         print(f"prodc: no config at {cfg_path}", file=sys.stderr)
-        return 2
+        return None
     try:
         cfg = Config.load(cfg_path)
-        needs = load_needs(cfg)
+        return cfg, load_needs(cfg)
     except (ConfigError, LoaderError) as exc:
         print(f"prodc: {exc}", file=sys.stderr)
+        return None
+
+
+def _cmd_status(args: argparse.Namespace) -> int:
+    loaded = _load_or_report(args)
+    if loaded is None:
         return 2
+    cfg, needs = loaded
     results = resolve(needs, cfg.adapters)
     summary = summarize(results)
     orphan_map = orphans(needs, cfg.adapters)
@@ -217,6 +225,82 @@ def _exit_code(args: argparse.Namespace, summary: Summary, orphan_total: int) ->
     return 0
 
 
+def _render_show(r: NeedResult) -> str:
+    """One need as a citable answer — the artifact you drop into a thread."""
+    need = r.need
+    who = (need.who + (f" ({need.label})" if need.label else "")) if need.who else "(unassigned)"
+    nm = f"  {r.delivered}/{r.total}" if r.total else ""
+    lines = [
+        f"{need.id}{'  !!' if need.must else ''}  {need.text}",
+        f"  who: {who}",
+        f"  grounds: {_LABEL[r.state]}{nm}    warrant: {_warrant(need)}",
+    ]
+    if need.sources:
+        lines.append("  sources:")
+        for s in need.sources:
+            bits = [s.kind.value]
+            bits += [f"{k}={v}" for k, v in (("who", s.who), ("date", s.date),
+                                             ("locator", s.locator)) if v]
+            line = "    - " + "  ".join(bits)
+            lines.append(line + (f'  "{s.quote}"' if s.quote else ""))
+    else:
+        lines.append("  sources: (none — opinion)")
+    if need.children:
+        lines.append(f"  children: {', '.join(need.children)}")
+    if need.proofs:
+        lines.append("  proofs:")
+        lines += [f"    - {d}" for d in r.detail]
+    elif not need.children:
+        lines.append("  proofs: (none — HOLE)")
+    lines += [f"  ⚠ {w}" for w in r.warnings]
+    return "\n".join(lines)
+
+
+def _show_json(r: NeedResult) -> str:
+    need = r.need
+    return json.dumps(
+        {
+            "id": need.id,
+            "text": need.text,
+            "who": need.who,
+            "label": need.label,
+            "must": need.must,
+            "state": r.state.value,
+            "grounds": r.state.value,
+            "warrant": _warrant(need),
+            "delivered": r.delivered,
+            "total": r.total,
+            "declared": r.declared,
+            "opinion": need.is_opinion,
+            "only_internal": need.only_internal,
+            "sources": [
+                {"kind": s.kind.value, "who": s.who, "date": s.date,
+                 "quote": s.quote, "locator": s.locator}
+                for s in need.sources
+            ],
+            "proofs": list(need.proofs),
+            "children": list(need.children),
+            "detail": r.detail,
+            "warnings": r.warnings,
+        },
+        indent=2,
+    )
+
+
+def _cmd_show(args: argparse.Namespace) -> int:
+    loaded = _load_or_report(args)
+    if loaded is None:
+        return 2
+    cfg, needs = loaded
+    by_id = {r.need.id: r for r in resolve(needs, cfg.adapters)}
+    r = by_id.get(args.need_id)
+    if r is None:
+        print(f"prodc: no need '{args.need_id}'", file=sys.stderr)
+        return 2
+    print(_show_json(r) if args.json else _render_show(r))
+    return 0
+
+
 def _git_rev(root: Path) -> str | None:
     head = root / ".git" / "HEAD"
     try:
@@ -263,6 +347,12 @@ def main(argv: list[str] | None = None) -> int:
     )
     st.set_defaults(func=_cmd_status)
 
+    sh = sub.add_parser("show", help="show one need as a citable answer")
+    sh.add_argument("need_id", help="the need id to show, e.g. N-1")
+    sh.add_argument("--config", default="prodc.toml", help="path to prodc.toml")
+    sh.add_argument("--json", action="store_true", help="machine-readable output")
+    sh.set_defaults(func=_cmd_show)
+
     args = parser.parse_args(argv)
     return int(args.func(args))
 

{prodc-0.3.1 → prodc-0.3.3}/src/prodc/config.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import cast
 
-from .adapters import Adapter, GherkinAdapter, PytestAdapter
+from .adapters import Adapter, FilesAdapter, GherkinAdapter, PytestAdapter
 
 
 class ConfigError(Exception):
@@ -70,6 +70,11 @@ class Config:
                     root=root / (sub if isinstance(sub, str) else "."),
                     results=results_s,
                 )
+            elif kind == "files":
+                sub = tbl.get("root", ".")
+                adapters[name] = FilesAdapter(root=root / (sub if isinstance(sub, str) else "."))
             else:
-                raise ConfigError(f"[proofs.{name}]: unknown kind {kind!r} (gherkin|pytest)")
+                raise ConfigError(
+                    f"[proofs.{name}]: unknown kind {kind!r} (gherkin|pytest|files)"
+                )
         return cls(root=root, need_globs=need_globs, adapters=adapters)

prodc-0.3.3/tests/test_adapters.py

@@ -0,0 +1,54 @@
+"""Adapters: pytest class-based node ids (#6) and the files adapter (#7)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from prodc.adapters import FilesAdapter, PytestAdapter
+from prodc.model import ProofState
+
+
+def _pytest_file(tmp_path: Path) -> PytestAdapter:
+    (tmp_path / "test_x.py").write_text(
+        "class TestX:\n"
+        "    def test_y(self):\n"
+        "        assert True\n"
+        "\n"
+        "def test_z():\n"
+        "    assert True\n",
+        encoding="utf-8",
+    )
+    return PytestAdapter(root=tmp_path, results=None)
+
+
+def test_pytest_resolves_class_based_node_id(tmp_path: Path) -> None:
+    adapter = _pytest_file(tmp_path)
+    r = adapter.resolve("test_x.py::TestX::test_y")
+    assert r.state is ProofState.DELIVERED and r.declared  # existence only
+
+
+def test_pytest_resolves_plain_function(tmp_path: Path) -> None:
+    assert _pytest_file(tmp_path).resolve("test_x.py::test_z").state is ProofState.DELIVERED
+
+
+def test_pytest_missing_method_in_class_is_broken(tmp_path: Path) -> None:
+    assert _pytest_file(tmp_path).resolve("test_x.py::TestX::test_nope").state is ProofState.BROKEN
+
+
+def test_pytest_missing_class_is_broken(tmp_path: Path) -> None:
+    assert _pytest_file(tmp_path).resolve("test_x.py::TestNope::test_y").state is ProofState.BROKEN
+
+
+def test_pytest_strips_parametrisation(tmp_path: Path) -> None:
+    r = _pytest_file(tmp_path).resolve("test_x.py::TestX::test_y[case1]")
+    assert r.state is ProofState.DELIVERED
+
+
+def test_files_adapter_existence_is_declared(tmp_path: Path) -> None:
+    (tmp_path / "verify.py").write_text("# a model\n", encoding="utf-8")
+    r = FilesAdapter(root=tmp_path).resolve("verify.py")
+    assert r.state is ProofState.DELIVERED and r.declared  # existence != passing
+
+
+def test_files_adapter_missing_is_broken(tmp_path: Path) -> None:
+    assert FilesAdapter(root=tmp_path).resolve("gone.py").state is ProofState.BROKEN

{prodc-0.3.1 → prodc-0.3.3}/tests/test_cli.py

@@ -126,3 +126,27 @@ def test_orphans_in_json(tmp_path: Path, capsys: pytest.CaptureFixture[str]) ->
     payload = json.loads(capsys.readouterr().out)
     assert payload["summary"]["orphans"] == 1
     assert payload["orphans"]["web"] == ["orders.feature#Unclaimed extra"]
+
+
+def test_show_single_need(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    code = main(["show", "D-1", "--config", str(_project(tmp_path))])
+    out = capsys.readouterr().out
+    assert code == 0
+    assert "D-1" in out and "a delivered need" in out
+    assert "grounds: DELIVERED" in out and "interview:John" in out
+    assert "I need this" in out  # the source quote
+
+
+def test_show_json(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    import json
+
+    main(["show", "D-1", "--config", str(_project(tmp_path)), "--json"])
+    p = json.loads(capsys.readouterr().out)
+    assert p["id"] == "D-1" and p["warrant"] == "interview:John"
+    assert p["sources"][0]["kind"] == "interview" and p["sources"][0]["who"] == "John"
+
+
+def test_show_unknown_need_exits_2(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    code = main(["show", "NOPE", "--config", str(_project(tmp_path))])
+    capsys.readouterr()
+    assert code == 2