@h2loop/autosar 0.0.0-stage → 1.0.1

package/python/ecuc_engine/model.py

@@ -0,0 +1,333 @@
+"""Project discovery + the ECUC value model.
+
+Files are classified by content, not by name or folder: a file holding ECUC-MODULE-DEF is a
+param-def source, one holding ECUC-MODULE-CONFIGURATION-VALUES is configuration, any other .arxml
+is "input" (System extract, SWCs, BSWMD) and only indexed for foreign-reference resolution.
+`.hydron/autosar.json` can pin each set with globs: {"paramDefs": [...], "config": [...], "input": [...]}.
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import Optional
+
+from . import defs as D
+from . import paths
+from .xmltree import Node, parse
+
+SKIP_DIRS = paths.TOOLING_DIRS  # kept for importers; discovery lives in paths.py
+PROJECT_CONFIG = os.path.join(".hydron", "autosar.json")
+
+MODULE_VALUES = "ECUC-MODULE-CONFIGURATION-VALUES"
+CONTAINER_VALUE = "ECUC-CONTAINER-VALUE"
+PARAM_VALUE_TAGS = {"ECUC-NUMERICAL-PARAM-VALUE", "ECUC-TEXTUAL-PARAM-VALUE", "ECUC-ADD-INFO-PARAM-VALUE"}
+REF_VALUE_TAGS = {"ECUC-REFERENCE-VALUE", "ECUC-INSTANCE-REFERENCE-VALUE"}
+
+
+@dataclass
+class ParamVal:
+    node: Node
+    def_ref: Optional[str]
+    def_dest: Optional[str]
+    tag: str
+    value: Optional[str]  # VALUE text / VALUE-REF text / None
+    value_node: Optional[Node]
+    dest: Optional[str] = None  # VALUE-REF DEST
+    is_auto: bool = False
+
+    @property
+    def name(self) -> str:
+        return (self.def_ref or "?").rsplit("/", 1)[-1]
+
+    @property
+    def is_ref(self) -> bool:
+        return self.tag in REF_VALUE_TAGS
+
+
+@dataclass
+class Elem:
+    """A module configuration (ECUC-MODULE-CONFIGURATION-VALUES) or a container value."""
+    node: Node
+    file: str
+    path: str
+    name: str
+    kind: str  # "module" | "container"
+    def_ref: Optional[str]
+    def_dest: Optional[str]
+    params: list = field(default_factory=list)  # ParamVal (params and refs)
+    children: list = field(default_factory=list)  # Elem
+    parent: Optional["Elem"] = None
+
+    @property
+    def line(self) -> int:
+        return self.node.line
+
+
+@dataclass
+class FileModel:
+    path: str
+    data: bytes
+    root: Node
+    elems: list  # top-level module Elems
+    identifiables: dict  # path -> (tag, line)
+    newline: bytes = b"\n"
+
+
+_MARKERS = {
+    "defs": re.compile(rb"<(?:[\w.-]+:)?ECUC-MODULE-DEF[\s>]"),
+    "config": re.compile(rb"<(?:[\w.-]+:)?ECUC-MODULE-CONFIGURATION-VALUES[\s>]"),
+}
+
+
+def _scan_markers(path: str) -> set:
+    """Which element kinds a file holds (element starts only; DEST="ECUC-MODULE-DEF" text does not count)."""
+    found = set()
+    tail = b""
+    try:
+        with open(path, "rb") as f:
+            while len(found) < len(_MARKERS):
+                chunk = f.read(1 << 20)
+                if not chunk:
+                    break
+                buf = tail + chunk
+                for k, rx in _MARKERS.items():
+                    if k not in found and rx.search(buf):
+                        found.add(k)
+                tail = buf[-96:]
+    except OSError:
+        pass
+    return found
+
+
+def _walk_arxml(root: str, notes: Optional[list] = None):
+    """Every ARXML file under root (any depth/folder name/extension case); sorted, deterministic."""
+    w = paths.walk(root, paths.is_arxml)
+    if notes is not None:
+        notes.extend(w.notes(root))
+    return w.files
+
+
+def _globs(root: str, pats, warnings: Optional[list] = None, what: str = "") -> list:
+    """Files/dirs/globs (relative or absolute, trailing slash optional) -> ARXML files on disk."""
+    pats = [pats] if isinstance(pats, str) else list(pats or [])
+    out = []
+    for p in paths.patterns(root, pats):
+        got = [f for f in p.expand(paths.is_arxml) if paths.is_arxml(f)]
+        if not got and warnings is not None:
+            warnings.append(f"{what or 'path'} {p.raw!r} matched no .arxml file under {root}")
+        out.extend(got)
+    seen, res = set(), []
+    for f in out:
+        a, real = os.path.abspath(f), os.path.realpath(f)
+        if real not in seen and os.path.isfile(a):
+            seen.add(real)
+            res.append(a)
+    return res
+
+
+@dataclass
+class Sources:
+    root: str
+    config: list
+    defs: list
+    input: list
+    warnings: list
+    origin: dict  # which mechanism found each set
+    notes: list = field(default_factory=list)  # info: hidden dirs included, cycles, caps
+
+
+def discover(root: str, config_files: Optional[list] = None, def_files: Optional[list] = None) -> Sources:
+    root = os.path.abspath(root)
+    cfg = {}
+    cfg_path = os.path.join(root, PROJECT_CONFIG)
+    warnings: list = []
+    if os.path.isfile(cfg_path):
+        try:
+            with open(cfg_path) as f:
+                cfg = json.load(f)
+        except Exception as e:
+            warnings.append(f"{PROJECT_CONFIG} is not valid JSON ({e}); ignoring it")
+    origin = {}
+    scanned = None
+    notes: list = []
+
+    def scan():
+        nonlocal scanned
+        if scanned is None:
+            scanned = {f: _scan_markers(f) for f in _walk_arxml(root, notes)}
+        return scanned
+
+    if def_files:
+        dfiles, origin["defs"] = _globs(root, def_files, warnings, "--defs"), "argument"
+    elif cfg.get("paramDefs"):
+        dfiles, origin["defs"] = _globs(root, cfg["paramDefs"], warnings, "paramDefs"), PROJECT_CONFIG
+    else:
+        dfiles, origin["defs"] = [f for f, m in scan().items() if "defs" in m], "auto-discovered"
+        if not dfiles and os.environ.get("AUTOSAR_PARAMDEFS"):
+            dfiles = _globs(root, os.environ["AUTOSAR_PARAMDEFS"].split(os.pathsep), warnings, "AUTOSAR_PARAMDEFS")
+            origin["defs"] = "AUTOSAR_PARAMDEFS"
+    if config_files:
+        cfiles, origin["config"] = _globs(root, config_files, warnings, "--config"), "argument"
+    elif cfg.get("config"):
+        cfiles, origin["config"] = _globs(root, cfg["config"], warnings, "config"), PROJECT_CONFIG
+    else:
+        cfiles, origin["config"] = [f for f, m in scan().items() if "config" in m], "auto-discovered"
+    if cfg.get("input"):
+        ifiles, origin["input"] = _globs(root, cfg["input"], warnings, "input"), PROJECT_CONFIG
+    else:
+        known = set(cfiles) | set(dfiles)
+        ifiles, origin["input"] = [f for f in scan() if f not in known], "auto-discovered"
+    if not dfiles:
+        warnings.append(
+            "No ECUC param definitions found (no ECUC-MODULE-DEF in the project, no paramDefs in "
+            f"{PROJECT_CONFIG}, AUTOSAR_PARAMDEFS unset). Values are readable but NOT validated, and edits "
+            "cannot add new elements. Point paramDefs at the AUTOSAR / vendor BSWMD param-def ARXML.")
+    return Sources(root, cfiles, dfiles, ifiles, warnings, origin, notes)
+
+
+def _dest(n: Optional[Node]) -> Optional[str]:
+    return n.attrs.get("DEST") if n is not None else None
+
+
+def build_file_model(path: str, data: bytes) -> FileModel:
+    root = parse(data)
+    elems: list = []
+    idents: dict = {}
+
+    def visit(node: Node, prefix: str, parent: Optional[Elem]):
+        sn = node.short_name
+        path_here = prefix
+        if sn is not None:
+            path_here = f"{prefix}/{sn}"
+            idents.setdefault(path_here, (node.tag, node.line))
+        if node.tag in (MODULE_VALUES, CONTAINER_VALUE) and sn is not None:
+            dr = node.child("DEFINITION-REF")
+            e = Elem(node=node, file=path, path=path_here, name=sn,
+                     kind="module" if node.tag == MODULE_VALUES else "container",
+                     def_ref=dr.text.strip() if dr is not None else None, def_dest=_dest(dr), parent=parent)
+            for coll in node.children:
+                if coll.tag in ("PARAMETER-VALUES", "REFERENCE-VALUES"):
+                    for pv in coll.children:
+                        e.params.append(_param(pv))
+            if parent is not None:
+                parent.children.append(e)
+            else:
+                elems.append(e)
+            for coll in node.children:
+                if coll.tag in ("CONTAINERS", "SUB-CONTAINERS"):
+                    for c in coll.children:
+                        visit(c, path_here, e)
+            return
+        for c in node.children:
+            if c.tag in ("SHORT-NAME", "DESC", "ADMIN-DATA", "INTRODUCTION", "ANNOTATIONS"):
+                continue
+            visit(c, path_here, parent if sn is None else None)
+
+    visit(root, "", None)
+    nl = b"\r\n" if b"\r\n" in data[:4096] else b"\n"
+    return FileModel(path, data, root, elems, idents, nl)
+
+
+def _param(pv: Node) -> ParamVal:
+    dr = pv.child("DEFINITION-REF")
+    vn = pv.child("VALUE") if pv.tag in PARAM_VALUE_TAGS else pv.child("VALUE-REF") or pv.child("VALUE-IREF")
+    val = None
+    if vn is not None:
+        val = vn.text.strip() if vn.tag != "VALUE-IREF" else "(instance-ref)"
+        if pv.tag == "ECUC-ADD-INFO-PARAM-VALUE":
+            val = " ".join(vn.text.split())
+    auto = (pv.child_text("IS-AUTO-VALUE") or "").lower() == "true"
+    return ParamVal(node=pv, def_ref=dr.text.strip() if dr is not None else None, def_dest=_dest(dr), tag=pv.tag,
+                    value=val, value_node=vn, dest=_dest(vn) if vn is not None and vn.tag == "VALUE-REF" else None,
+                    is_auto=auto)
+
+
+def index_identifiables(path: str) -> dict:
+    """Fast path -> (tag, line=0) index of a non-config ARXML (System, SWC, BSWMD) for foreign refs."""
+    out: dict = {}
+    stack: list = []  # (short_name or None)
+    pending: list = []
+    try:
+        for ev, el in ET.iterparse(path, events=("start", "end")):
+            tag = el.tag.rsplit("}", 1)[-1]
+            if ev == "start":
+                stack.append(None)
+                pending.append(tag)
+            else:
+                if tag == "SHORT-NAME" and len(stack) >= 2:
+                    stack[-2] = (el.text or "").strip()
+                    p = "/" + "/".join(s for s in stack[:-1] if s)
+                    out.setdefault(p, (pending[-2], 0))
+                stack.pop()
+                pending.pop()
+                el.clear()
+    except ET.ParseError:
+        pass
+    return out
+
+
+class Project:
+    def __init__(self, root: str, config_files=None, def_files=None, load_input: bool = True):
+        self.sources = discover(root, config_files, def_files)
+        self.root = self.sources.root
+        self.warnings = list(self.sources.warnings)
+        self.defs = D.load_defs(self.sources.defs) if self.sources.defs else D.DefIndex()
+        if self.sources.defs and not self.defs:
+            self.warnings.append("param-def files were found but contain no ECUC-MODULE-DEF")
+        self.files: dict[str, FileModel] = {}
+        for f in self.sources.config:
+            self._load(f)
+        self.foreign: dict = {}
+        self.input_loaded = False
+        if load_input:
+            for f in self.sources.input:
+                self.foreign.update(index_identifiables(f))
+            self.input_loaded = bool(self.sources.input)
+        self.reindex()
+
+    def _load(self, f: str, data: Optional[bytes] = None):
+        if data is None:
+            with open(f, "rb") as fh:
+                data = fh.read()
+        try:
+            self.files[f] = build_file_model(f, data)
+        except Exception as e:
+            self.warnings.append(f"{self.rel(f)}: XML parse error: {e}")
+
+    def reload(self, f: str, data: bytes):
+        self._load(f, data)
+        self.reindex()
+
+    def reindex(self):
+        self.by_path: dict[str, list] = {}
+        self.modules: list = []
+        self.identifiables: dict = dict(self.foreign)
+        for fm in self.files.values():
+            for p, v in fm.identifiables.items():
+                self.identifiables.setdefault(p, v + (fm.path,))
+            for m in fm.elems:
+                self.modules.append(m)
+                for e in _iter_elems(m):
+                    self.by_path.setdefault(e.path, []).append(e)
+
+    def rel(self, f: str) -> str:
+        try:
+            r = os.path.relpath(f, self.root)
+            return f if r.startswith("..") else r
+        except ValueError:
+            return f
+
+    def find(self, path: str) -> list:
+        return self.by_path.get(path.rstrip("/"), [])
+
+
+def _iter_elems(e: Elem):
+    stack = [e]
+    while stack:
+        x = stack.pop()
+        yield x
+        stack.extend(reversed(x.children))

package/python/ecuc_engine/paths.py

@@ -0,0 +1,221 @@
+"""Layout-agnostic file discovery and path filters.
+
+Nothing here assumes Config/, Input/, Source/ or Output/:
+- walk() finds files at any depth, skips only tooling dirs, includes other hidden dirs (and says so),
+  follows symlinked dirs once with cycle protection, and stops at a cap with a clear message.
+- Pattern() matches a user path argument against files: an exact file, a directory (= path prefix,
+  with or without trailing slash), a glob with ** (relative to the root, or anywhere when it has no
+  slash), relative or absolute.
+"""
+from __future__ import annotations
+
+import fnmatch
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Callable, Iterable, Optional
+
+TOOLING_DIRS = {".git", ".hg", ".svn", ".hydron", ".venv", "venv", "node_modules", "__pycache__", ".cache",
+                ".idea", ".vscode", ".pytest_cache", ".mypy_cache", ".tox"}
+MAX_FILES = int(os.environ.get("AUTOSAR_MAX_FILES", "200000"))
+GLOB_CHARS = set("*?[")
+
+
+def is_arxml(name: str) -> bool:
+    return name.lower().endswith(".arxml")  # .arxml, .ARXML, .ecuc.arxml, ...
+
+
+def is_c(name: str) -> bool:
+    return name.lower().endswith((".c", ".h"))
+
+
+@dataclass
+class Walk:
+    files: list = field(default_factory=list)
+    hidden: list = field(default_factory=list)  # hidden dirs that contributed files
+    cycles: list = field(default_factory=list)  # symlinked dirs skipped as already visited
+    truncated: bool = False
+    visited_dirs: int = 0
+
+    def notes(self, root: str) -> list:
+        out = []
+        for d in self.hidden:
+            out.append(f"included hidden directory {os.path.relpath(d, root)}/ (it contains matching files)")
+        for d in self.cycles[:5]:
+            out.append(f"symlinked directory {os.path.relpath(d, root)} skipped: already visited (cycle)")
+        if self.truncated:
+            out.append(f"file walk stopped at {MAX_FILES} files; narrow the scan with .hydron/autosar.json globs "
+                       "or raise AUTOSAR_MAX_FILES")
+        return out
+
+
+def walk(root: str, want: Callable[[str], bool], cap: int = 0) -> Walk:
+    """All files under ``root`` (any depth) for which ``want(name)`` is true, sorted per directory."""
+    cap = cap or MAX_FILES
+    res = Walk()
+    seen: set = set()
+    hidden_hits: dict = {}
+
+    def visit(d: str, hidden_anc: Optional[str]):
+        real = os.path.realpath(d)
+        if real in seen:
+            res.cycles.append(d)
+            return
+        seen.add(real)
+        res.visited_dirs += 1
+        try:
+            entries = sorted(os.scandir(d), key=lambda e: e.name)
+        except OSError:
+            return
+        subdirs = []
+        for e in entries:
+            if res.truncated:
+                return
+            try:
+                if e.is_dir(follow_symlinks=True):
+                    if e.name not in TOOLING_DIRS:
+                        subdirs.append(e)
+                elif e.is_file(follow_symlinks=True) and want(e.name):
+                    res.files.append(e.path)
+                    if hidden_anc:
+                        hidden_hits.setdefault(hidden_anc, True)
+                    if len(res.files) >= cap:
+                        res.truncated = True
+                        return
+            except OSError:
+                continue
+        for e in subdirs:
+            anc = hidden_anc or (e.path if e.name.startswith(".") else None)
+            visit(e.path, anc)
+
+    if os.path.isdir(root):
+        visit(root, None)
+    res.hidden = sorted(hidden_hits)
+    return res
+
+
+def _glob_regex(pat: str) -> re.Pattern:
+    """Glob with ** (any number of dirs), * and ? (within a segment), [..] classes."""
+    out, i = [], 0
+    while i < len(pat):
+        if pat.startswith("**/", i):
+            out.append("(?:.*/)?")
+            i += 3
+        elif pat.startswith("**", i):
+            out.append(".*")
+            i += 2
+        elif pat[i] == "*":
+            out.append("[^/]*")
+            i += 1
+        elif pat[i] == "?":
+            out.append("[^/]")
+            i += 1
+        elif pat[i] == "[":
+            j = pat.find("]", i)
+            if j < 0:
+                out.append(re.escape(pat[i]))
+                i += 1
+            else:
+                out.append(fnmatch.translate(pat[i:j + 1])[4:-3])
+                i = j + 1
+        else:
+            out.append(re.escape(pat[i]))
+            i += 1
+    return re.compile("".join(out) + r"\Z", re.IGNORECASE)  # *.ARXML == *.arxml
+
+
+def _norm(p: str) -> str:
+    return p.replace("\\", "/")
+
+
+class Pattern:
+    """One user-supplied path argument, resolved against ``root``."""
+
+    def __init__(self, root: str, raw: str):
+        self.raw = raw
+        p = os.path.expanduser(str(raw).strip())
+        stripped = p.rstrip("/\\") or p
+        self.is_glob = any(ch in GLOB_CHARS for ch in stripped)
+        full = stripped if os.path.isabs(stripped) else os.path.join(root, stripped)
+        self.abs = os.path.normpath(full)
+        self.real = os.path.realpath(self.abs)
+        self.root = os.path.realpath(root)
+        if self.is_glob:
+            self.kind = "glob"
+            self.rx = _glob_regex(_norm(stripped))
+            self.anywhere = "/" not in _norm(stripped).lstrip("./")  # "*.arxml" or "Com*.arxml": match basenames
+        elif os.path.isdir(self.abs):
+            self.kind = "dir"
+        elif os.path.isfile(self.abs):
+            self.kind = "file"
+        else:
+            self.kind = "missing"
+
+    def matches(self, path: str) -> bool:
+        a = os.path.normpath(os.path.abspath(path))
+        r = os.path.realpath(a)
+        if self.kind == "file":
+            return a == self.abs or r == self.real
+        if self.kind == "dir":
+            return any(x.startswith(base.rstrip(os.sep) + os.sep) for x in (a, r) for base in (self.abs, self.real))
+        if self.kind == "glob":
+            rel = _norm(os.path.relpath(r, self.root))
+            cands = [rel, _norm(a), _norm(r), os.path.basename(a)] if self.anywhere else [rel, _norm(a), _norm(r)]
+            return any(self.rx.match(c) for c in cands) or (self.anywhere and any(self.rx.match(c.split("/")[-1]) for c in cands))
+        # missing on disk: maybe a path relative to root with odd separators, or a basename
+        name = _norm(str(self.raw)).strip("/")
+        rel = _norm(os.path.relpath(r, self.root))
+        return rel == name or rel.startswith(name + "/") or os.path.basename(a) == name
+
+    def expand(self, want: Callable[[str], bool]) -> list:
+        """Files on disk this pattern names (dirs walked recursively)."""
+        if self.kind == "file":
+            return [self.abs]
+        if self.kind == "dir":
+            return walk(self.abs, want).files
+        if self.kind == "glob":
+            # Walk (cycle-safe, tooling dirs skipped) from the glob's fixed prefix instead of glob.glob,
+            # which follows symlink loops and is case-sensitive.
+            stripped = _norm(os.path.expanduser(str(self.raw).strip())).rstrip("/")
+            fixed = []
+            for seg in stripped.split("/"):
+                if any(ch in GLOB_CHARS for ch in seg):
+                    break
+                fixed.append(seg)
+            prefix = "/".join(fixed)
+            base = prefix if os.path.isabs(stripped) else os.path.join(self.root, prefix) if prefix else self.root
+            if self.anywhere:
+                base = self.root
+            if not os.path.isdir(base):
+                return []
+            return [f for f in walk(base, want).files if self.matches(f)]
+        return []
+
+
+def patterns(root: str, raws: Optional[Iterable]) -> list:
+    return [Pattern(root, r) for r in (raws or []) if str(r).strip()]
+
+
+def expand(root: str, raws: Optional[Iterable], want: Callable[[str], bool]) -> list:
+    """Files named by the patterns, each real file once (symlinked routes collapse)."""
+    seen, out = set(), []
+    for p in patterns(root, raws):
+        for f in p.expand(want):
+            real = os.path.realpath(f)
+            if real not in seen:
+                seen.add(real)
+                out.append(os.path.abspath(f))
+    return out
+
+
+def select(root: str, raws: Optional[Iterable], files: Iterable[str]) -> tuple:
+    """(matched files, patterns that matched nothing) for a filter over already-loaded files."""
+    pats = patterns(root, raws)
+    files = list(files)
+    hit, empty = [], []
+    for p in pats:
+        m = [f for f in files if p.matches(f)]
+        if not m:
+            empty.append(p.raw)
+        hit.extend(m)
+    return sorted(set(hit)), empty

package/python/ecuc_engine/rules/__init__.py

@@ -0,0 +1,82 @@
+"""Hand-written semantic rule packs (the "H" checks the param defs cannot express).
+
+A rule is a function registered with @rule(...). It receives a RuleContext and yields
+(elem, line, message, def_ref) tuples; the registry adds the rule id, severity and spec citation.
+Rules are keyed by module-relative DEFINITION-REFs ("Com/ComConfig/ComSignal/ComBitPosition"), so
+they work for /AUTOSAR/EcucDefs/... and vendor-relocated defs alike, and run with or without the
+param defs loaded. To add a pack: create a module here with @rule functions and import it below.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Iterable, Optional
+
+from ..model import Elem, ParamVal, Project
+
+
+@dataclass
+class Rule:
+    id: str
+    severity: str
+    cite: str
+    title: str
+    fn: Callable
+
+
+RULES: list = []
+
+
+def rule(id: str, severity: str, cite: str, title: str):
+    def deco(fn):
+        RULES.append(Rule(id, severity, cite, title, fn))
+        return fn
+    return deco
+
+
+class RuleContext:
+    def __init__(self, project: Project):
+        self.p = project
+        self.defs = project.defs
+        self._by_rel: Optional[dict] = None
+
+    def rel(self, def_ref: Optional[str]) -> str:
+        return self.defs.rel(def_ref) if def_ref else ""
+
+    def containers(self, rel_def: str) -> list:
+        """All container values (first fragment per path) whose def is ``rel_def`` (module-relative)."""
+        if self._by_rel is None:
+            self._by_rel = {}
+            for path, group in self.p.by_path.items():
+                self._by_rel.setdefault(self.rel(group[0].def_ref), []).append(group[0])
+        return self._by_rel.get(rel_def, [])
+
+    def values(self, e: Elem, name: str) -> list:
+        return [pv for g in self.p.find(e.path) for pv in g.params if pv.name == name]
+
+    def value(self, e: Elem, name: str) -> Optional[ParamVal]:
+        v = self.values(e, name)
+        return v[0] if v else None
+
+    def text(self, e: Elem, name: str) -> Optional[str]:
+        v = self.value(e, name)
+        return v.value if v is not None else None
+
+    def target(self, pv: Optional[ParamVal]) -> Optional[Elem]:
+        if pv is None or not pv.value:
+            return None
+        hit = self.p.find(pv.value.strip())
+        return hit[0] if hit else None
+
+    def module_of(self, e: Elem) -> Elem:
+        while e.parent is not None:
+            e = e.parent
+        return e
+
+
+def run_rules(project: Project) -> Iterable[dict]:
+    from . import com, handles  # noqa: F401  (registers the packs)
+    ctx = RuleContext(project)
+    for r in RULES:
+        for e, line, msg, def_ref in r.fn(ctx):
+            yield {"file": project.rel(e.file), "line": line, "path": e.path, "rule": r.id,
+                   "severity": r.severity, "message": f"{msg} [{r.cite}]", "defRef": def_ref}