@h2loop/autosar 1.0.1 → 1.1.0

package/python/ecuc_engine/arxml_edit.py

@@ -0,0 +1,387 @@
+"""Structured, in-place edits of non-ECUC ARXML (System/ECU extract, SWCs, interfaces).
+
+Ops (paths are AUTOSAR paths of identifiables; tags are XML element names):
+  {"op": "add", "parent_path": "/Communication/ISignals", "element": "I-SIGNAL", "short_name": "X",
+   "values": {"LENGTH": 8, "SYSTEM-SIGNAL-REF": "->/Communication/SystemSignals/X",
+              "INIT-VALUE": {"NUMERICAL-VALUE-SPECIFICATION": {"VALUE": 0}}}}
+  {"op": "set", "path": "/Communication/Pdus/P/X", "element": "START-POSITION", "value": 40}
+  {"op": "remove", "path": "/Communication/ISignals/X"}
+
+- The aggregating collection (ELEMENTS, I-SIGNAL-TO-PDU-MAPPINGS, ...) is inferred from the AUTOSAR schema
+  (autosar-data) when not given; children are written in schema order.
+- Every *-REF / *-TREF gets its DEST from the referenced element's actual tag ("->/path"), looked up in all
+  loaded ARXML (config, extract, and the elements added in the same call). A target that does not exist is an
+  error, unless given explicitly as {"ref": "/path", "dest": "TAG"}.
+- Bytes outside the inserted/changed spans are untouched; the file is strictly re-loaded with autosar-data
+  afterwards and nothing is written if any op or check fails.
+"""
+from __future__ import annotations
+
+import difflib
+import os
+import re
+from typing import Optional
+
+from .model import Project
+from .xmltree import Node, escape, escape_attr, line_indent, parse
+
+
+class ArxmlEditError(Exception):
+    pass
+
+
+def _ad():
+    try:
+        import autosar_data as ad  # type: ignore
+        return ad
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _version(data: bytes):
+    ad = _ad()
+    if ad is None:
+        return None
+    m = re.search(rb"AUTOSAR_([0-9A-Za-z_-]+)\.xsd", data[:2000])
+    name = "AUTOSAR_" + (m.group(1).decode().replace("-", "_") if m else "00054")
+    return getattr(ad.AutosarVersion, name, None) or ad.AutosarVersion.AUTOSAR_00054
+
+
+class FileTree:
+    def __init__(self, path: str, data: bytes):
+        self.path, self.data = path, data
+        self.root = parse(data)
+        self.by_path: dict = {}
+        self._index(self.root, "")
+        self.nl = b"\r\n" if b"\r\n" in data[:4096] else b"\n"
+
+    def _index(self, n: Node, prefix: str):
+        sn = n.short_name
+        p = f"{prefix}/{sn}" if sn is not None else prefix
+        if sn is not None:
+            self.by_path.setdefault(p, n)
+        for c in n.children:
+            self._index(c, p)
+
+    def chain(self, node: Node) -> list:
+        out = []
+        while node is not None:
+            out.append(node.tag)
+            node = node.parent
+        return list(reversed(out))
+
+
+def _etype(tags: list, version):
+    """ElementType for a tag chain from the AUTOSAR root (None without autosar-data)."""
+    ad = _ad()
+    if ad is None or version is None:
+        return None
+    m = ad.AutosarModel()
+    t = m.root_element.element_type
+    for tag in tags[1:]:
+        t = t.find_sub_element(tag, version)
+        if t is None:
+            return None
+    return t
+
+
+def _order(etype) -> list:
+    return [s.element_name for s in etype.sub_elements_spec] if etype is not None else []
+
+
+class ArxmlEditor:
+    def __init__(self, project: Project):
+        self.p = project
+        self.files: dict = {}
+        self.original: dict = {}
+        self.added_tags: dict = {}  # path -> tag of elements added in this call
+
+    # ---------- files / lookup ----------
+    def tree_for(self, path: str) -> tuple:
+        """(FileTree, node) holding the identifiable ``path``."""
+        for ft in self.files.values():
+            if path in ft.by_path:
+                return ft, ft.by_path[path]
+        hit = self.p.identifiables.get(path)
+        f = hit[2] if hit and len(hit) > 2 else None
+        if f is None:
+            for cand in self.p.sources.input + self.p.sources.config:
+                ft = self.load(cand)
+                if path in ft.by_path:
+                    return ft, ft.by_path[path]
+            raise ArxmlEditError(f"no ARXML element at {path}")
+        ft = self.load(f)
+        if path not in ft.by_path:
+            raise ArxmlEditError(f"{path} not found in {self.p.rel(f)}")
+        return ft, ft.by_path[path]
+
+    def load(self, f: str) -> FileTree:
+        if f not in self.files:
+            with open(f, "rb") as fh:
+                data = fh.read()
+            self.original.setdefault(f, data)
+            self.files[f] = FileTree(f, data)
+        return self.files[f]
+
+    def patch(self, ft: FileTree, start: int, end: int, repl: bytes):
+        data = ft.data[:start] + repl + ft.data[end:]
+        self.files[ft.path] = FileTree(ft.path, data)
+
+    def dest_of(self, target: str) -> Optional[str]:
+        if target in self.added_tags:
+            return self.added_tags[target]
+        hit = self.p.identifiables.get(target)
+        if hit:
+            return hit[0]
+        for ft in self.files.values():
+            n = ft.by_path.get(target)
+            if n is not None:
+                return n.tag
+        return None
+
+    # ---------- rendering ----------
+    def render(self, tag: str, short_name: Optional[str], values, etype, version, depth: int) -> list:
+        lines = []
+        attrs = ""
+        if isinstance(values, dict) and "@attrs" in values:
+            attrs = "".join(f' {k}="{escape_attr(str(v))}"' for k, v in values["@attrs"].items())
+        if not isinstance(values, dict):
+            return [(depth, self.leaf(tag, values))]
+        lines.append((depth, f"<{tag}{attrs}>"))
+        if short_name is not None:
+            lines.append((depth + 1, f"<SHORT-NAME>{escape(short_name)}</SHORT-NAME>"))
+        order = _order(etype)
+        keys = [k for k in values if not k.startswith("@") and k != "SHORT-NAME"]
+        if order:
+            unknown = [k for k in keys if k not in order]
+            if unknown:
+                raise ArxmlEditError(f"{tag} has no sub-element(s) {unknown} in this AUTOSAR schema; allowed: "
+                                     f"{', '.join(o for o in order if o != 'SHORT-NAME')[:600]}")
+            keys.sort(key=order.index)
+        for k in keys:
+            v = values[k]
+            for one in (v if isinstance(v, list) else [v]):
+                sub = etype.find_sub_element(k, version) if etype is not None else None
+                if isinstance(one, dict) and "ref" not in one:
+                    sn = one.get("SHORT-NAME")
+                    lines.extend(self.render(k, sn, one, sub, version, depth + 1))
+                else:
+                    lines.append((depth + 1, self.leaf(k, one)))
+        lines.append((depth, f"</{tag}>"))
+        return lines
+
+    def leaf(self, tag: str, v) -> str:
+        if isinstance(v, dict) and "ref" in v:
+            target, dest = str(v["ref"]), v.get("dest") or self.dest_of(str(v["ref"]))
+            if not dest:
+                raise ArxmlEditError(f"{tag} -> {target}: target does not exist (add it first, or give "
+                                     "{{\"ref\": ..., \"dest\": \"TAG\"}})")
+            return f'<{tag} DEST="{escape_attr(dest)}">{escape(target)}</{tag}>'
+        if isinstance(v, str) and v.startswith("->"):
+            target = v[2:].strip()
+            if not (tag.endswith("-REF") or tag.endswith("-TREF") or tag.endswith("-IREF")):
+                raise ArxmlEditError(f"{tag} is not a reference element but got {v!r}")
+            dest = self.dest_of(target)
+            if not dest:
+                raise ArxmlEditError(f"{tag} -> {target}: no element with that path in the loaded ARXML (add it first "
+                                     "in the same call, or pass {\"ref\": path, \"dest\": TAG})")
+            return f'<{tag} DEST="{escape_attr(dest)}">{escape(target)}</{tag}>'
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        if (tag.endswith("-REF") or tag.endswith("-TREF")) and isinstance(v, str) and v.startswith("/"):
+            return self.leaf(tag, "->" + v)
+        return f"<{tag}>{escape(str(v))}</{tag}>"
+
+    def emit(self, ft: FileTree, lines: list, base: bytes, unit: bytes) -> bytes:
+        return ft.nl.join(base + unit * d + s.encode("utf-8") for d, s in lines)
+
+    @staticmethod
+    def unit_of(ft: FileTree, node: Node) -> bytes:
+        if node.children:
+            ci = line_indent(ft.data, node.children[0].start) or b""
+            ni = line_indent(ft.data, node.start) or b""
+            if len(ci) > len(ni) and ci.startswith(ni):
+                return ci[len(ni):]
+        return b"  "
+
+    # ---------- ops ----------
+    def op_add(self, op: dict):
+        parent_path, tag = op.get("parent_path"), op.get("element")
+        if not parent_path or not tag:
+            raise ArxmlEditError("add needs parent_path and element")
+        ft, parent = self.tree_for(parent_path.rstrip("/"))
+        version = _version(ft.data)
+        ptype = _etype(ft.chain(parent), version)
+        coll = op.get("collection")
+        if coll is None and ptype is not None:
+            if ptype.find_sub_element(tag, version) is None:
+                for c in _order(ptype):
+                    ct = ptype.find_sub_element(c, version)
+                    if ct is not None and ct.find_sub_element(tag, version) is not None:
+                        coll = c
+                        break
+                if coll is None:
+                    raise ArxmlEditError(f"{tag} cannot be placed under {parent.tag} {parent_path} in this schema")
+        elif coll is None:
+            coll = "ELEMENTS" if parent.tag == "AR-PACKAGE" else None
+        sn = op.get("short_name")
+        new_path = f"{parent_path.rstrip('/')}/{sn}" if sn else None
+        if new_path and (new_path in ft.by_path or self.p.identifiables.get(new_path)):
+            raise ArxmlEditError(f"{new_path} already exists")
+        ctype = ptype.find_sub_element(coll, version) if (ptype is not None and coll) else ptype
+        etype = ctype.find_sub_element(tag, version) if ctype is not None else None
+        if new_path:
+            self.added_tags[new_path] = tag
+        lines = self.render(tag, sn, op.get("values") or {}, etype, version, 0)
+        unit = self.unit_of(ft, parent)
+        if not coll:  # a direct child: place it at its schema position
+            ind = (line_indent(ft.data, parent.children[0].start) if parent.children else None) or b""
+            self._insert_leaf(ft, parent, tag, self.emit(ft, lines, ind, unit).lstrip())
+            return new_path
+        holder = parent.child(coll)
+        if holder is not None and holder.children:
+            last = holder.children[-1]
+            ind = line_indent(ft.data, last.start) or b""
+            self.patch(ft, last.end, last.end, ft.nl + self.emit(ft, lines, ind, unit))
+            return new_path
+        if holder is not None:  # empty collection element
+            ind = line_indent(ft.data, holder.start) or b""
+            body = [(0, f"<{holder.tag}>")] + [(d + 1, s) for d, s in lines] + [(0, f"</{holder.tag}>")]
+            self.patch(ft, holder.start, holder.end, self.emit(ft, body, ind, unit).lstrip())
+            return new_path
+        # create the collection at its schema position among the parent's children
+        body = [(0, f"<{coll}>")] + [(d + 1, s) for d, s in lines] + [(0, f"</{coll}>")]
+        order = _order(ptype)
+        after = set(order[order.index(coll) + 1:]) if coll in order else set()
+        ind = (line_indent(ft.data, parent.children[0].start) if parent.children else None) or \
+              ((line_indent(ft.data, parent.start) or b"") + unit)
+        before = next((c for c in parent.children if c.tag in after), None)
+        if before is not None:
+            self.patch(ft, before.start, before.start, self.emit(ft, body, ind, unit).lstrip() + ft.nl + ind)
+        else:
+            last = parent.children[-1]
+            self.patch(ft, last.end, last.end, ft.nl + self.emit(ft, body, ind, unit))
+        return new_path
+
+    def own_child(self, node: Node, tag: str) -> Optional[Node]:
+        stack = list(node.children)
+        while stack:
+            c = stack.pop(0)
+            if c.tag == tag:
+                return c
+            if c.short_name is None:
+                stack.extend(c.children)
+        return None
+
+    def op_set(self, op: dict):
+        path, tag = op.get("path"), op.get("element")
+        if not path or not tag or "value" not in op:
+            raise ArxmlEditError("set needs path, element and value")
+        ft, node = self.tree_for(path.rstrip("/"))
+        leaf = self.own_child(node, tag)
+        text = self.leaf(tag, op["value"]).encode("utf-8")
+        if leaf is None:
+            self._insert_leaf(ft, node, tag, text)
+            return
+        self.patch(ft, leaf.start, leaf.end, text)
+
+    def _insert_leaf(self, ft: FileTree, node: Node, tag: str, text: bytes):
+        version = _version(ft.data)
+        order = _order(_etype(ft.chain(node), version))
+        if order and tag not in order:
+            raise ArxmlEditError(f"{node.tag} has no sub-element {tag} in this schema")
+        after = set(order[order.index(tag) + 1:]) if tag in order else set()
+        ind = line_indent(ft.data, node.children[0].start) if node.children else b""
+        before = next((c for c in node.children if c.tag in after), None)
+        if before is not None:
+            self.patch(ft, before.start, before.start, text + ft.nl + (ind or b""))
+        else:
+            last = node.children[-1]
+            self.patch(ft, last.end, last.end, ft.nl + (ind or b"") + text)
+
+    def op_remove(self, op: dict):
+        path = (op.get("path") or "").rstrip("/")
+        ft, node = self.tree_for(path)
+        start = node.start
+        if line_indent(ft.data, start) is not None:
+            nl = ft.data.rfind(b"\n", 0, start)
+            start = nl if nl >= 0 else start
+        self.patch(ft, start, node.end, b"")
+
+    # ---------- checks ----------
+    def check(self) -> list:
+        """References in touched files resolve, with DEST equal to the target's tag; schema re-load."""
+        problems = []
+        known = dict(self.p.identifiables)
+        for ft in self.files.values():
+            for path, n in ft.by_path.items():
+                known[path] = (n.tag, n.line, ft.path)
+        for f, ft in self.files.items():
+            if ft.data == self.original.get(f):
+                continue
+            before = set(re.findall(rb"<([A-Z0-9-]+-T?REF)\b[^>]*>([^<]*)<", self.original[f]))
+            for n in ft.root.iter():
+                if not (n.tag.endswith("-REF") or n.tag.endswith("-TREF")):
+                    continue
+                tgt = n.text.strip()
+                if (n.tag.encode(), tgt.encode()) in before:
+                    continue  # pre-existing reference, untouched
+                dest = n.attrs.get("DEST")
+                hit = known.get(tgt)
+                if not dest:
+                    problems.append(f"{self.p.rel(f)}:{n.line} {n.tag} -> {tgt}: missing DEST attribute")
+                if hit is None:
+                    problems.append(f"{self.p.rel(f)}:{n.line} {n.tag} -> {tgt}: target does not exist")
+                elif dest and hit[0] != dest:
+                    problems.append(f"{self.p.rel(f)}:{n.line} {n.tag} DEST={dest} but {tgt} is a {hit[0]}")
+            from .edit import schema_check
+            if schema_check(f, self.original[f]) is None:
+                err = schema_check(f, ft.data)
+                if err:
+                    problems.append(f"{self.p.rel(f)}: schema: {err}")
+        return problems
+
+
+def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
+    if isinstance(ops, dict):
+        ops = [ops]
+    if not isinstance(ops, list) or not ops or not all(isinstance(o, dict) for o in ops):
+        return {"ok": False, "error": "ops must be a non-empty list of op objects"}
+    ed = ArxmlEditor(project)
+    created = []
+    try:
+        for i, op in enumerate(ops):
+            kind = op.get("op")
+            try:
+                if kind == "add":
+                    created.append(ed.op_add(op))
+                elif kind == "set":
+                    ed.op_set(op)
+                elif kind == "remove":
+                    ed.op_remove(op)
+                else:
+                    raise ArxmlEditError(f"unknown op {kind!r} (add/set/remove)")
+            except ArxmlEditError as e:
+                raise ArxmlEditError(f"op {i} ({kind} {op.get('path') or op.get('parent_path')}): {e}") from None
+    except ArxmlEditError as e:
+        return {"ok": False, "error": str(e), "written": False}
+    problems = ed.check()
+    changes = []
+    for f, ft in ed.files.items():
+        if ft.data != ed.original[f]:
+            a = ed.original[f].decode("utf-8", "replace").splitlines(keepends=True)
+            b = ft.data.decode("utf-8", "replace").splitlines(keepends=True)
+            rel = project.rel(f)
+            changes.append({"file": rel, "diff": "".join(difflib.unified_diff(a, b, f"a/{rel}", f"b/{rel}", n=1))})
+    if problems:
+        return {"ok": False, "error": "edit rejected; nothing written", "problems": problems, "changes": changes,
+                "written": False}
+    if not dry_run:
+        for f, ft in ed.files.items():
+            if ft.data != ed.original[f]:
+                tmp = f + ".arxml-tmp"
+                with open(tmp, "wb") as fh:
+                    fh.write(ft.data)
+                os.replace(tmp, f)
+    return {"ok": True, "written": not dry_run, "created": [c for c in created if c], "changes": changes,
+            "schemaChecked": _ad() is not None}