Refine requirement type autodiscovery

Author: FScholPer

docs/conf.py

@@ -18,7 +18,3 @@
 extensions = [
     "score_sphinx_bundle",
 ]
-
-# Configure traceability metrics explicitly for this repository.
-score_metamodel_requirement_types = "tool_req"
-score_metamodel_include_external_needs = False

docs/how-to/dashboards_and_quality_gates.rst

@@ -40,25 +40,35 @@ Typical Setup
 
 For details, see :ref:`setup`.
 
-Minimal Configuration Example
------------------------------
+Configuration
+-------------
+
+Default Behavior (No Configuration Needed)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By default, ``score_metamodel`` autodiscovers requirement types from the
+repository needs present in the current build. Requirement types are identified
+from ``needs_types`` entries tagged with ``requirement`` or
+``requirement_excl_process``.
 
-In ``docs/conf.py``:
+This is the recommended setup for most repositories.
+
+Optional Override for Requirement Types
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a repository needs to force a specific set of requirement types, set an
+explicit override in ``docs/conf.py``:
 
 .. code-block:: python
 
    score_metamodel_requirement_types = "feat_req,comp_req,aou_req"
-   score_metamodel_include_external_needs = False
 
-By default, ``score_metamodel`` autodiscovers requirement types from the
-repository needs that are present in the current build. If
-``score_metamodel_requirement_types`` is set, that explicit list overrides
+When this setting is provided, the explicit list is used instead of
 autodiscovery.
 
 Use ``score_metamodel_include_external_needs = True`` only in repositories that
 intentionally aggregate requirements across module dependencies, such as
-integration repositories. Use ``False`` for module repositories to gate only on
-local traceability.
+integration repositories.
 
 Building the Dashboard
 ----------------------
@@ -92,7 +102,7 @@ There are two common modes:
 
 **Module repository**
 
-- Set ``score_metamodel_include_external_needs = False``.
+- No setting needed. Local-only scope is the default.
 - Gate only on the needs owned by the repository itself.
 - Use this for per-module implementation progress and traceability.
 

src/extensions/score_metamodel/__init__.py

@@ -157,13 +157,7 @@ def _write_metrics_json(app: Sphinx, exception: Exception | None) -> None:
 
 
 def _get_need_value(need: Any, key: str, default: Any = None) -> Any:
-    getter = getattr(need, "get", None)
-    if callable(getter):
-        return getter(key, default)
-    try:
-        return need[key]
-    except Exception:
-        return default
+    return need.get(key, default)
 
 
 def _as_requirement_directive(need_type: Any) -> str | None:
@@ -198,11 +192,15 @@ def _discover_requirement_types(
         need_type: Any = _get_need_value(need, "type", None)
         if isinstance(need_type, str):
             present_types.add(need_type)
+
     discovered = tagged_requirements.intersection(present_types)
-    if not discovered:
-        # Fallback for repositories that use *_req directives but do not tag
-        # requirement types in needs_types.
-        discovered = {t for t in present_types if t.endswith("_req")}
+
+    if tagged_requirements and not discovered:
+        logger.warning(
+            "No requirement types discovered in current build for tagged "
+            "needs_types requirement directives."
+        )
+
     if discovered:
         logger.info(
             "score_metamodel_requirement_types is not configured; "

src/extensions/score_metamodel/tests/test_traceability_metrics_json_generation.py

@@ -98,47 +98,10 @@ def get_needs_view(self) -> dict[str, dict[str, object]]:
         }
 
 
-class _NeedObj:
-    def __init__(self, payload: dict[str, object]):
-        self._payload = payload
-
-    def get(self, key: str, default: object | None = None) -> object | None:
-        return self._payload.get(key, default)
-
-
-class _FakeObjectNeedsData:
-    def __init__(self, env: object):
-        self._env = env
-
-    def get_needs_view(self) -> dict[str, _NeedObj]:
-        return {
-            "LOCAL_REQ": _NeedObj(
-                {
-                    "id": "LOCAL_REQ",
-                    "type": "tool_req",
-                    "implemented": "YES",
-                    "source_code_link": "",
-                    "testlink": "",
-                    "is_external": False,
-                }
-            ),
-            "LOCAL_FEAT": _NeedObj(
-                {
-                    "id": "LOCAL_FEAT",
-                    "type": "feat_req",
-                    "implemented": "YES",
-                    "source_code_link": "",
-                    "testlink": "",
-                    "is_external": False,
-                }
-            ),
-        }
-
-
 def _app(
     tmp_path: Path,
     include_external: bool,
-    requirement_types: str = "tool_req",
+    requirement_types: str = "",
     needs_types: list[dict[str, object]] | None = None,
 ) -> SimpleNamespace:
     discovered_types = needs_types or [
@@ -281,7 +244,7 @@ def test_write_metrics_json_empty_when_no_types_configured_or_discovered(
     assert payload["metrics_by_type"] == {}
 
 
-def test_autodiscovery_falls_back_to_present_req_suffix_types(
+def test_autodiscovery_without_tagged_requirement_types_is_empty(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
     monkeypatch.setattr(metamodel_init, "SphinxNeedsData", _FakeNeedsData)
@@ -300,7 +263,7 @@ def test_autodiscovery_falls_back_to_present_req_suffix_types(
     )
 
     payload = json.loads((tmp_path / "metrics.json").read_text(encoding="utf-8"))
-    assert set(payload["metrics_by_type"].keys()) == {"feat_req", "tool_req"}
+    assert payload["metrics_by_type"] == {}
 
 
 def test_autodiscovery_respects_include_external_scope(
@@ -315,7 +278,11 @@ def test_autodiscovery_respects_include_external_scope(
                 tmp_path,
                 include_external=True,
                 requirement_types="",
-                needs_types=[{"directive": "workflow", "tags": []}],
+                needs_types=[
+                    {"directive": "tool_req", "tags": ["requirement_excl_process"]},
+                    {"directive": "feat_req", "tags": ["requirement"]},
+                    {"directive": "gd_req", "tags": ["requirement"]},
+                ],
             ),
         ),
         None,
@@ -325,28 +292,6 @@ def test_autodiscovery_respects_include_external_scope(
     assert set(payload["metrics_by_type"].keys()) == {"feat_req", "gd_req", "tool_req"}
 
 
-def test_autodiscovery_handles_needitem_like_objects(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    monkeypatch.setattr(metamodel_init, "SphinxNeedsData", _FakeObjectNeedsData)
-
-    metamodel_init._write_metrics_json(
-        cast(
-            Sphinx,
-            _app(
-                tmp_path,
-                include_external=False,
-                requirement_types="",
-                needs_types=[{"directive": "workflow", "tags": []}],
-            ),
-        ),
-        None,
-    )
-
-    payload = json.loads((tmp_path / "metrics.json").read_text(encoding="utf-8"))
-    assert set(payload["metrics_by_type"].keys()) == {"feat_req", "tool_req"}
-
-
 @pytest.mark.parametrize(
     ("requirement_types", "include_external", "should_exist", "expected_totals"),
     [