fix(deployment): exclude self-name from tier detection

`detect_tier` used a substring match on Cargo.toml / pyproject.toml to
decide whether the repo depends on hyperi-rustlib / hyperi-pylib. That
also matched the library's own `name = "hyperi-rustlib"` declaration,
so the library's own repo got dispatched as a Tier 1 / Tier 2 consumer
and the Generate stage failed with "no Rust binary found".

`_depends_on` now extracts the manifest's own package name from
[package] / [project] / [tool.poetry] and returns False on self-match,
so library repos correctly land in Tier.NONE. Consumer projects whose
own name shares a prefix (e.g. "hyperi-rustlib-extras") are unaffected
because the check is exact-equals, not substring.

Generic fix — applies to any *lib repo (hyperi-rustlib, hyperi-pylib,
future hyperi-golib) and to consumer projects with similar prefixes
(dfe-* etc.). 9 new tests in TestSelfMatchExclusion cover the cases:
own-name-only, dev-deps loop, poetry section, single-quoted, real
consumer, prefix-collision, inline comment, and out-of-section name.

Publish: true

Author: catinspace-au

src/hyperi_ci/deployment/detect.py

@@ -94,25 +94,91 @@ def _depends_on(manifest: Path, package_name: str) -> bool:
         dependencies = ["hyperi-pylib>=2.24"]
         dependencies = ["hyperi-pylib[metrics]>=2.24"]
 
-    Doesn't try to parse TOML because:
+    **Self-match exclusion.** If the manifest declares its own package
+    name as ``package_name`` (i.e. this manifest IS the library, not a
+    consumer of it), returns False. Without this, the library's own
+    repo gets misdispatched as a Tier 1/2 consumer and the
+    deployment-artefact producer fails with "no Rust binary found" /
+    equivalent. The check is generic — applies to any rustlib /
+    pylib / future *lib and to consumer projects whose own name
+    happens to share a prefix.
+
+    Doesn't try to parse TOML beyond pulling the ``name`` field out of
+    a recognised top-level section because:
+
       1. Avoids hauling `tomllib` in just for tier detection.
       2. Catches every form (workspace inheritance, extras, comments)
          that a stricter parse would have to handle case by case.
-      3. False positives only if the package name appears in another
-         context (e.g., a comment mentioning it) — acceptable, since
-         the consequence is "we try to invoke generate-artefacts and
-         the binary fails clearly" rather than silent miscategorisation.
+      3. False positives in the dep-match are bounded: the consequence
+         is "we try to invoke generate-artefacts and the binary fails
+         clearly" rather than silent miscategorisation.
 
     Args:
         manifest: Path to Cargo.toml or pyproject.toml.
         package_name: Dependency name to look for.
 
     Returns:
-        True if the substring appears in the manifest's text.
+        True if the substring appears AND the manifest isn't itself
+        the named package; False otherwise.
 
     """
     try:
         text = manifest.read_text(encoding="utf-8", errors="replace")
     except OSError:
         return False
-    return package_name in text
+    if package_name not in text:
+        return False
+    return _manifest_self_name(text) != package_name
+
+
+# Top-level tables whose ``name`` field is the manifest's own package
+# name. Listed in scan precedence — the first match wins, so a Cargo
+# manifest's ``[package] name`` beats any later table (unlikely in
+# Cargo, but pyproject.toml can legitimately have both ``[project]``
+# and ``[tool.poetry]`` and we treat them equivalently).
+_SELF_NAME_SECTIONS: frozenset[str] = frozenset(
+    {"[package]", "[project]", "[tool.poetry]"}
+)
+
+
+def _manifest_self_name(text: str) -> str | None:
+    """Extract the manifest's own package name, if declared.
+
+    Scans for a ``name = "..."`` (or single-quoted) line inside one of
+    the recognised self-name sections (:data:`_SELF_NAME_SECTIONS`).
+    Returns the first match. No TOML parser — line-scoped, tolerant of
+    extra whitespace around ``=``.
+
+    Args:
+        text: Full manifest text.
+
+    Returns:
+        The declared package name, or ``None`` if no recognised
+        declaration is found.
+
+    """
+    current_section: str | None = None
+    for raw in text.splitlines():
+        stripped = raw.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            current_section = stripped
+            continue
+        if current_section not in _SELF_NAME_SECTIONS:
+            continue
+        # Cheap pre-filter: skip lines that don't even start with "name".
+        if not stripped.startswith("name"):
+            continue
+        eq = stripped.find("=")
+        if eq < 0:
+            continue
+        # Confirm the LHS is exactly "name" (avoids matching "name-foo").
+        lhs = stripped[:eq].strip()
+        if lhs != "name":
+            continue
+        rhs = stripped[eq + 1 :].strip()
+        # Strip a trailing inline comment if present.
+        if "#" in rhs:
+            rhs = rhs[: rhs.index("#")].strip()
+        if len(rhs) >= 2 and rhs[0] in {'"', "'"} and rhs[-1] == rhs[0]:
+            return rhs[1:-1]
+    return None

tests/unit/deployment/test_detect_tier.py

@@ -120,6 +120,105 @@ def test_python_wins_over_other(self, tmp_path: Path) -> None:
         assert detect_tier(tmp_path) == Tier.PYTHON
 
 
+class TestSelfMatchExclusion:
+    """A library's own repo is NOT a Tier 1/2 consumer of itself.
+
+    These tests cover the case where a library's Cargo.toml /
+    pyproject.toml has its own package name (e.g. `hyperi-rustlib`)
+    in the `[package]` / `[project]` table. The substring match would
+    otherwise misdetect the library as a consumer and dispatch the
+    Tier 1/2 producer, which then fails with "no binary found".
+    """
+
+    def test_hyperi_rustlib_own_repo_is_not_rust(self, tmp_path: Path) -> None:
+        # The library's own Cargo.toml has `name = "hyperi-rustlib"` in
+        # [package] but no `hyperi-rustlib = ...` dep line.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"\nversion = "2.7.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_rustlib_with_self_in_dev_deps_still_excluded(
+        self, tmp_path: Path
+    ) -> None:
+        # Hypothetical: library lists its own name in [dev-dependencies]
+        # for an example-binary workspace pattern. Still not a consumer.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"\nversion = "2.7.0"\n'
+            '[dev-dependencies]\nhyperi-rustlib = { path = "." }\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_pylib_own_repo_is_not_python(self, tmp_path: Path) -> None:
+        (tmp_path / "pyproject.toml").write_text(
+            '[project]\nname = "hyperi-pylib"\nversion = "2.24.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_pylib_poetry_section_also_excluded(self, tmp_path: Path) -> None:
+        # Poetry-managed projects use [tool.poetry] instead of [project].
+        (tmp_path / "pyproject.toml").write_text(
+            '[tool.poetry]\nname = "hyperi-pylib"\nversion = "2.24.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_single_quoted_name_excluded(self, tmp_path: Path) -> None:
+        # TOML allows single-quoted strings — must still match.
+        (tmp_path / "Cargo.toml").write_text(
+            "[package]\nname = 'hyperi-rustlib'\nversion = '2.7.0'\n",
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_consumer_with_real_dep_still_detected(self, tmp_path: Path) -> None:
+        # A real consumer has its own name AND lists the library as a dep.
+        # Self-match exclusion must not break this case.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "dfe-loader"\n[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+    def test_consumer_with_similar_prefix_not_misdetected(self, tmp_path: Path) -> None:
+        # `name = "hyperi-rustlib-extras"` should NOT count as self-match
+        # for `hyperi-rustlib` because the full string differs. This
+        # consumer DOES depend on hyperi-rustlib.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib-extras"\n'
+            '[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+    def test_name_with_trailing_comment_handled(self, tmp_path: Path) -> None:
+        # Inline comments after the name field shouldn't break parsing.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"  # the library itself\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_name_outside_recognised_section_not_self_match(
+        self, tmp_path: Path
+    ) -> None:
+        # A `name = "hyperi-rustlib"` in some other table (e.g.
+        # [features.something]) shouldn't count as the manifest's own
+        # name. We only treat [package] / [project] / [tool.poetry] as
+        # self-name sections.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "consumer-app"\n'
+            "[features.weird]\n"
+            'name = "hyperi-rustlib"\n'
+            '[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+
 class TestTierEnum:
     """`Tier` enum has the four values expected by callers."""