sysmlpy 0.69.0__tar.gz → 0.70.0__tar.gz

{sysmlpy-0.69.0 → sysmlpy-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.69.0
+Version: 0.70.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)

{sysmlpy-0.69.0 → sysmlpy-0.70.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.69.0"
+version = "0.70.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"

{sysmlpy-0.69.0 → sysmlpy-0.70.0}/src/sysmlpy/__init__.py

@@ -34,7 +34,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.69.0"
+__version__ = "0.70.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.69.0 → sysmlpy-0.70.0}/src/sysmlpy/semantic.py

@@ -1236,6 +1236,55 @@ class ExpressionIdentifierCollector:
             self._walk(child, results, child_scope)
 
 
+def _find_payload_parameters(node: Any) -> list:
+    """Locate every ``PayloadParameter`` dict in a grammar tree."""
+    out: list = []
+
+    def walk(n: Any) -> None:
+        if isinstance(n, dict):
+            if n.get("name") == "PayloadParameter":
+                out.append(n)
+            for v in n.values():
+                if isinstance(v, (dict, list)):
+                    walk(v)
+        elif isinstance(n, list):
+            for item in n:
+                if isinstance(item, (dict, list)):
+                    walk(item)
+
+    walk(node)
+    return out
+
+
+def _payload_reference(payload: Any) -> str | None:
+    """The name a ``PayloadParameter`` refers to, if any.
+
+    Bare ``accept Sig`` → the OwnedFeatureTyping QualifiedName.
+    Guarded ``accept Sig when ...`` → ``identification.declaredName``
+    (only when no typing is present — with both, the identification
+    is a fresh declaration, not a reference).
+    """
+    if not isinstance(payload, dict):
+        return None
+    feature = payload.get("feature") or {}
+    rels = feature.get("ownedRelationship")
+    rel_list = rels if isinstance(rels, list) else         [rels] if isinstance(rels, dict) else []
+    for rel in rel_list:
+        t = ((rel.get("type") or {}).get("type") or {}) \
+            if isinstance(rel, dict) else {}
+        names = t.get("names")
+        if isinstance(names, list) and names:
+            return "::".join(str(n) for n in names)
+    if rel_list:
+        return None  # typed payload — identification is a declaration
+    ident = payload.get("identification")
+    if isinstance(ident, dict):
+        name = ident.get("declaredName")
+        if name:
+            return str(name)
+    return None
+
+
 def _find_owned_expressions(node: Any) -> list[dict]:
     """Locate every ``OwnedExpression`` dict in a grammar definition tree."""
     out: list[dict] = []
@@ -2329,6 +2378,9 @@ class SemanticAnalyzer:
         issues.extend(self._check_connector_ends_compatible(model))
         issues.extend(self._check_multiplicity_bounds_valid(model))
         issues.extend(self._check_state_machines(model))
+        issues.extend(self._check_trigger_payloads(model, symtab, lib_roots))
+        issues.extend(self._check_requirement_coverage(model))
+        issues.extend(self._check_trace_targets(model, symtab, lib_roots))
 
         # Step 6: Stylistic checks (warnings, not errors)
         if style_checks:
@@ -2914,6 +2966,219 @@ class SemanticAnalyzer:
 
     # -- OCL well-formedness constraints ------------------------------------
 
+    def _check_trigger_payloads(
+        self,
+        model: Any,
+        symtab: "SymbolTable",
+        lib_roots: list,
+    ) -> list[SemanticIssue]:
+        """Resolve ``accept <Sig>`` trigger payload references (Goal 9).
+
+        The shorthand ``accept <Sig> [when <expr>]`` binds a transition
+        trigger to a payload/signal definition.  A typo there is
+        silent today: the transition simply never fires, and nothing
+        in analyze() looks at payload names.  Two parse shapes exist
+        (both verified against the visitor output):
+
+        - bare ``accept Sig`` — PayloadParameter carries an
+          OwnedFeatureTyping → QualifiedName reference;
+        - guarded ``accept Sig when expr`` — the visitor parks the
+          name in ``identification.declaredName`` with no typing.
+
+        In both the name is meant as a reference to a declared
+        definition, so each payload name is resolved against the
+        symbol table in the transition's scope.  Unresolved payloads
+        produce UNRESOLVED_TRIGGER_PAYLOAD errors.  When both an
+        identification and a typing are present (``accept e : T``),
+        only the typing is a reference — the identification is a
+        fresh declaration.
+        """
+        issues: list[SemanticIssue] = []
+        try:
+            from sysmlpy.sim import load_model_grammar
+            visit = load_model_grammar(model)
+        except Exception:
+            return issues
+
+        for element, scope_path in self._walk_usages(model):
+            # Transitions live inside State definitions' grammar trees
+            # (no TransitionUsage object of their own) — extracting at
+            # the State level attributes each payload to exactly one
+            # element and keeps the scope path correct.
+            if type(element).__name__ != "State":
+                continue
+            grammar_def = None
+            grammar = getattr(element, "grammar", None)
+            if grammar is None:
+                continue
+            try:
+                grammar_def = grammar.get_definition()
+            except Exception:
+                continue
+            if not isinstance(grammar_def, dict):
+                continue
+            for payload in _find_payload_parameters(grammar_def):
+                ref = _payload_reference(payload)
+                if not ref:
+                    continue
+                if self._is_resolved(ref, symtab, scope_path, lib_roots):
+                    continue
+                issues.append(SemanticIssue(
+                    severity="error",
+                    code="UNRESOLVED_TRIGGER_PAYLOAD",
+                    message=(
+                        f"Accept trigger payload '{ref}' in "
+                        f"{type(element).__name__} "
+                        f"'{getattr(element, 'name', '<anonymous>')}' "
+                        "does not resolve to a defined symbol; the "
+                        "transition can never fire"),
+                    element=element,
+                    reference=ref,
+                ))
+        return issues
+
+    @staticmethod
+    def _walk_usages(model: Any):
+        """Yield ``(element, scope_path)`` for every usage-like element."""
+        def walk(element, scope_path):
+            name = getattr(element, "name", None)
+            elem_type = type(element).__name__
+            is_container = getattr(element, "is_definition", False)                 or elem_type == "Package"
+            child_scope = scope_path
+            if is_container and name is not None and elem_type != "Model":
+                child_scope = scope_path + [name]
+            yield element, scope_path
+            for child in getattr(element, "children", []):
+                yield from walk(child, child_scope)
+
+        yield from walk(model, [])
+
+    def _check_requirement_coverage(self, model: Any) -> list[SemanticIssue]:
+        """Cross-check requirement traceability coverage (Goal 9).
+
+        Reuses the Goal 2 traceability extractor: every requirement
+        *usage* with no ``satisfy`` *and* no ``verify`` relationship
+        yields a REQUIREMENT_UNCOVERED warning.  ``requirement def``
+        declarations are categories/templates, not traceable
+        instances, and are never flagged.  Partially covered
+        requirements (satisfied but unverified or vice versa) are not
+        flagged — that is a project-progress signal, not a
+        well-formedness problem.
+        """
+        issues: list[SemanticIssue] = []
+        try:
+            from sysmlpy.traceability import extract_traceability
+            report = extract_traceability(model)
+        except Exception:
+            return issues
+        for trace in report.uncovered():
+            if getattr(trace, "is_definition", False):
+                continue
+            issues.append(SemanticIssue(
+                severity="warning",
+                code="REQUIREMENT_UNCOVERED",
+                message=(
+                    f"Requirement '{trace.name}' has no satisfy and "
+                    "no verify relationships"),
+                reference=trace.name,
+            ))
+        return issues
+
+    def _check_trace_targets(
+        self,
+        model: Any,
+        symtab: "SymbolTable",
+        lib_roots: list,
+    ) -> list[SemanticIssue]:
+        """Resolve ``satisfy <req> by <part>`` targets (Goal 9).
+
+        A typo'd satisfy target is silent today — worse, the Goal 2
+        traceability extractor materializes the dangling edge as a
+        *phantom requirement* in coverage reports, so the real
+        requirement reads uncovered while a fake one appears traced.
+        Each satisfy target reference is resolved against the symbol
+        table in the satisfying part's scope; unresolved targets
+        produce UNRESOLVED_TRACE_TARGET errors.
+        """
+        issues: list[SemanticIssue] = []
+        for element, scope_path in self._walk_usages(model):
+            grammar = getattr(element, "grammar", None)
+            if grammar is None or \
+                    grammar.__class__.__name__ != "SatisfyRequirementUsage":
+                continue
+            ors = getattr(grammar, "ors", None)
+            if ors is None:
+                continue
+            try:
+                ref = ors.dump().strip().rstrip(";").strip()
+            except Exception:
+                continue
+            if not ref:
+                continue
+            if self._is_resolved(ref, symtab, scope_path, lib_roots):
+                # Kind check: the target must be a requirement.
+                # (Library-resolved targets yield no element here and
+                # are left alone — conservative by design.)
+                found = self._resolve_element(ref, symtab, scope_path)
+                if found is not None and \
+                        type(found).__name__ != "Requirement":
+                    issues.append(SemanticIssue(
+                        severity="warning",
+                        code="TRACE_TARGET_NOT_REQUIREMENT",
+                        message=(
+                            f"satisfy target '{ref}' resolves to a "
+                            f"{type(found).__name__}, not a "
+                            "requirement"),
+                        element=element,
+                        reference=ref,
+                    ))
+                continue
+            issues.append(SemanticIssue(
+                severity="error",
+                code="UNRESOLVED_TRACE_TARGET",
+                message=(
+                    f"satisfy target '{ref}' in "
+                    f"{type(element).__name__} "
+                    f"'{getattr(element, 'name', '<anonymous>')}' does "
+                    "not resolve to a defined requirement"),
+                element=element,
+                reference=ref,
+            ))
+        return issues
+
+    @staticmethod
+    def _resolve_element(
+        ref_str: str,
+        symtab: "SymbolTable",
+        scope_path: list[str],
+    ):
+        """The model element *ref_str* resolves to, if any.
+
+        Mirrors the symbol-table walk of :meth:`_is_resolved` (without
+        the library-index shortcuts, which resolve to no model
+        element).
+        """
+        current = symtab
+        for scope_name in scope_path:
+            child = current._children.get(scope_name)
+            if child is not None:
+                current = child
+            else:
+                break
+        found = current.lookup(ref_str)
+        if found is not None:
+            return found
+        if "::" in ref_str:
+            parts = ref_str.split("::")
+            table = current
+            for part in parts[:-1]:
+                found = table.lookup(part)
+                if found is None:
+                    return None
+                table = table._children.get(part, table)
+            return table.lookup(parts[-1])
+        return None
+
     def _check_state_machines(self, model: Any) -> list[SemanticIssue]:
         """OCL well-formedness for ``state def`` machines (Goal 9).
 
@@ -2930,12 +3195,12 @@ class SemanticAnalyzer:
         issues: list[SemanticIssue] = []
         try:
             # Lazy import: sim pulls the boxes-view collector and the
-            # evaluator; no import cycle at module level.
+            # evaluator; no import cycle at module level.  The sim
+            # extra is optional — skip these checks without it.
             from sysmlpy.sim import SimulationError, build_state_machine
-
-            visit = None
-            from sysmlpy import boxes_view as _bv
-            visit = _bv  # noqa: F841 — ensures boxes_view loads once
+        except ImportError:
+            return issues
+        try:
             machines = self._collect_machines(model)
         except SimulationError:
             return issues