@anik-2/autosar 0.0.0-stage → 0.1.1

package/python/ecuc_engine/edit.py

@@ -0,0 +1,429 @@
+"""In-place ECUC edits.
+
+Ops (addressed by AUTOSAR path; names are def SHORT-NAMEs):
+  {"op": "set",    "path": "/Pkg/Com/ComConfig/Sig1", "param": "ComBitPosition", "value": 8}
+  {"op": "set",    "path": "/Pkg/Com/ComConfig/Sig1/ComBitPosition", "value": 8}      # param in path
+  {"op": "set",    "path": ".../ComIPdu1", "param": "ComIPduSignalRef", "value": ["->/a", "->/b"]}  # multi
+  {"op": "add",    "path": "/Pkg/Com/ComConfig", "container": "ComSignal:Sig2", "values": {...ECUC JSON...}}
+  {"op": "add",    "path": ".../ComIPdu1", "param": "ComIPduSignalRef", "value": "->/Pkg/Com/ComConfig/Sig2"}
+  {"op": "remove", "path": "/Pkg/Com/ComConfig/Sig2"}
+  {"op": "remove", "path": ".../ComIPdu1", "param": "ComIPduSignalRef" [, "value": "->/..."]}
+
+The engine picks the value element (NUMERICAL / TEXTUAL / REFERENCE), the DEFINITION-REF and its
+DEST, and the VALUE-REF DEST from the param defs. Each op patches only the byte span it changes, in
+the file the element lives in; everything else (UUIDs, order, comments, formatting) is untouched.
+All ops apply in memory first; files are written only if every op succeeds.
+"""
+from __future__ import annotations
+
+import difflib
+import os
+import uuid
+from typing import Optional
+
+from . import defs as D
+from .model import CONTAINER_VALUE, Elem, Project
+from .validate import _resolve_def, validate
+from .values import check_value, expected_value_tag, from_json
+from .xmltree import Node, escape, line_indent
+
+CONTAINER_ORDER = ["DEFINITION-REF", "PARAMETER-VALUES", "REFERENCE-VALUES", "SUB-CONTAINERS", "VARIATION-POINT"]
+MODULE_ORDER = ["DEFINITION-REF", "ECUC-DEF-EDITION", "IMPLEMENTATION-CONFIG-VARIANT", "MODULE-DESCRIPTION-REF",
+                "POST-BUILD-VARIANT-USED", "CONTAINERS"]
+
+
+class EditError(Exception):
+    pass
+
+
+class Editor:
+    def __init__(self, project: Project):
+        self.p = project
+        self.original: dict[str, bytes] = {}
+        self.notes: list = []
+
+    # ---------- low-level byte patching ----------
+    def data(self, f: str) -> bytes:
+        return self.p.files[f].data
+
+    def patch(self, f: str, start: int, end: int, repl: bytes):
+        data = self.data(f)
+        self.original.setdefault(f, data)
+        self.p.reload(f, data[:start] + repl + data[end:])
+        if f not in self.p.files:
+            raise EditError(f"internal: patched file {f} no longer parses")
+
+    def nl(self, f: str) -> bytes:
+        return self.p.files[f].newline
+
+    def indent(self, f: str, node: Node) -> bytes:
+        return line_indent(self.data(f), node.start) or b""
+
+    def unit(self, f: str, node: Node) -> bytes:
+        if node.children:
+            ci, ni = self.indent(f, node.children[0]), self.indent(f, node)
+            if len(ci) > len(ni) and ci.startswith(ni):
+                return ci[len(ni):]
+        return b"  "
+
+    def emit(self, f: str, lines: list, base: bytes, unit: bytes) -> bytes:
+        nl = self.nl(f)
+        return nl.join(base + unit * d + s.encode("utf-8") for d, s in lines)
+
+    def remove_node(self, f: str, node: Node):
+        parent = node.parent
+        if parent is not None and len(parent.children) == 1 and parent.tag in (
+                "PARAMETER-VALUES", "REFERENCE-VALUES", "SUB-CONTAINERS", "CONTAINERS"):
+            return self.remove_node(f, parent)
+        data = self.data(f)
+        start = node.start
+        if line_indent(data, start) is not None:
+            nlpos = data.rfind(b"\n", 0, start)
+            if nlpos >= 0:
+                start = nlpos - 1 if nlpos > 0 and data[nlpos - 1:nlpos] == b"\r" else nlpos
+        self.patch(f, start, node.end, b"")
+
+    def insert_into(self, f: str, owner: Node, coll_tag: str, items: list):
+        """Append rendered items (each a list of (depth, text)) to owner's collection, creating it if needed."""
+        unit = self.unit(f, owner)
+        coll = owner.child(coll_tag)
+        nl = self.nl(f)
+        if coll is not None and coll.children:
+            last = coll.children[-1]
+            ind = self.indent(f, last)
+            text = b"".join(nl + self.emit(f, it, ind, unit) for it in items)
+            self.patch(f, last.end, last.end, text)
+            return
+        lines = [(0, f"<{coll_tag}>")] + [(d + 1, s) for it in items for d, s in it] + [(0, f"</{coll_tag}>")]
+        if coll is not None:  # empty collection element
+            self.patch(f, coll.start, coll.end, self.emit(f, lines, self.indent(f, coll), unit).lstrip())
+            return
+        order = MODULE_ORDER if owner.tag == "ECUC-MODULE-CONFIGURATION-VALUES" else CONTAINER_ORDER
+        after = set(order[order.index(coll_tag) + 1:]) if coll_tag in order else set()
+        ind = self.indent(f, owner.children[0]) if owner.children else self.indent(f, owner) + unit
+        before = next((c for c in owner.children if c.tag in after), None)
+        if before is not None:
+            self.patch(f, before.start, before.start, self.emit(f, lines, ind, unit).lstrip() + nl + ind)
+        else:
+            last = owner.children[-1]
+            self.patch(f, last.end, last.end, nl + self.emit(f, lines, ind, unit))
+
+    # ---------- rendering ----------
+    def ref_dest(self, pd: Optional[D.DefNode], target: str) -> str:
+        hit = self.p.find(target)
+        if hit:
+            return hit[0].node.tag
+        ident = self.p.identifiables.get(target)
+        if ident:
+            return ident[0]
+        if pd is not None and pd.dest_type:
+            return pd.dest_type
+        return CONTAINER_VALUE
+
+    def render_param(self, pd: D.DefNode, def_ref: str, value) -> list:
+        tag = expected_value_tag(pd)
+        if tag is None or tag in ("ECUC-INSTANCE-REFERENCE-VALUE", "ECUC-ADD-INFO-PARAM-VALUE"):
+            raise EditError(f"{pd.name}: {pd.kind} values cannot be edited by this engine yet")
+        text = from_json(pd, value)
+        lines = [(0, f"<{tag}>"), (1, f'<DEFINITION-REF DEST="{pd.tag}">{escape(def_ref)}</DEFINITION-REF>')]
+        if tag == "ECUC-REFERENCE-VALUE":
+            lines.append((1, f'<VALUE-REF DEST="{self.ref_dest(pd, text)}">{escape(text)}</VALUE-REF>'))
+        else:
+            lines.append((1, f"<VALUE>{escape(text)}</VALUE>"))
+        lines.append((0, f"</{tag}>"))
+        return lines
+
+    def render_container(self, f: str, cd: D.DefNode, def_ref: str, name: str, values: dict) -> list:
+        with_uuid = b"<ECUC-CONTAINER-VALUE UUID=" in self.data(f)
+        head = f'<ECUC-CONTAINER-VALUE UUID="{uuid.uuid4()}">' if with_uuid else "<ECUC-CONTAINER-VALUE>"
+        lines = [(0, head), (1, f"<SHORT-NAME>{escape(name)}</SHORT-NAME>"),
+                 (1, f'<DEFINITION-REF DEST="{cd.tag}">{escape(def_ref)}</DEFINITION-REF>')]
+        params, refs, subs = [], [], []
+        by_name = {self.p.defs.by_path[x].name: self.p.defs.by_path[x] for x in cd.params + cd.refs}
+        cdefs = {self.p.defs.by_path[x].name: self.p.defs.by_path[x] for x in cd.containers}
+        order = {n: i for i, n in enumerate(list(by_name) + list(cdefs))}
+        for k in sorted((k for k in values if not k.startswith("@")), key=lambda k: order.get(k.split(":")[0], 1 << 30)):
+            v = values[k]
+            if isinstance(v, dict):
+                dname, _, sname = k.partition(":")
+                sname = sname or dname
+                sd = cdefs.get(dname)
+                if sd is None:
+                    raise EditError(f"{cd.name} has no sub-container def '{dname}' (allowed: {', '.join(cdefs) or 'none'})")
+                subs.append(self.render_container(f, sd, f"{def_ref}/{sd.name}", sname, v))
+                continue
+            pd = by_name.get(k)
+            if pd is None:
+                raise EditError(f"{cd.name} has no parameter/reference '{k}' (allowed: {', '.join(by_name) or 'none'})")
+            for one in (v if isinstance(v, list) else [v]):
+                self.check(pd, one)
+                (refs if D.is_ref_kind(pd.kind or "") else params).append(self.render_param(pd, f"{def_ref}/{pd.name}", one))
+        for tag, items in (("PARAMETER-VALUES", params), ("REFERENCE-VALUES", refs), ("SUB-CONTAINERS", subs)):
+            if items:
+                lines.append((1, f"<{tag}>"))
+                lines += [(d + 2, s) for it in items for d, s in it]
+                lines.append((1, f"</{tag}>"))
+        lines.append((0, "</ECUC-CONTAINER-VALUE>"))
+        return lines
+
+    def check(self, pd: D.DefNode, value):
+        if D.is_ref_kind(pd.kind or ""):
+            t = from_json(pd, value)
+            if not t.startswith("/"):
+                raise EditError(f"{pd.name}: reference value must be an AUTOSAR path ('->/Pkg/...'), got {value!r}")
+            return
+        probs = check_value(pd, from_json(pd, value))
+        if probs and not self.force:
+            raise EditError("; ".join(m for _, m in probs) + " (pass force:true to write it anyway)")
+
+    # ---------- lookups ----------
+    def container(self, path: str) -> list:
+        g = self.p.find(path)
+        if not g:
+            raise EditError(f"no ECUC module/container at {path}")
+        return g
+
+    def child_def(self, e: Elem, name: str, want: str) -> D.DefNode:
+        d = _resolve_def(self.p.defs, e.def_ref)
+        if d is None:
+            raise EditError(f"no param def loaded for {e.def_ref}; cannot {want} (load the param defs, see ecuc_read warnings)")
+        pool = d.containers if want == "container" else d.params + d.refs
+        for x in pool:
+            if self.p.defs.by_path[x].name == name:
+                return self.p.defs.by_path[x]
+        names = ", ".join(self.p.defs.by_path[x].name for x in pool) or "none"
+        raise EditError(f"{d.name} has no {want} def '{name}' (allowed: {names})")
+
+    def split_param_path(self, op: dict):
+        path, param = op.get("path", "").rstrip("/"), op.get("param")
+        if param or self.p.find(path):
+            return path, param
+        parent, _, last = path.rpartition("/")
+        if self.p.find(parent):
+            return parent, last
+        raise EditError(f"no ECUC element at {path} (nor at its parent {parent}); read the module first for exact paths")
+
+    # ---------- ops ----------
+    def apply(self, ops: list, force: bool = False):
+        self.force = force
+        check_ops(ops)
+        for i, op in enumerate(ops):
+            kind = op.get("op")
+            try:
+                if kind == "set":
+                    self.op_set(op)
+                elif kind == "add":
+                    self.op_add(op)
+                elif kind == "remove":
+                    self.op_remove(op)
+                else:
+                    raise EditError(f"unknown op {kind!r} (use set/add/remove)")
+            except EditError as e:
+                raise EditError(f"op {i} ({kind} {op.get('path')}): {e}") from None
+
+    def op_set(self, op: dict):
+        path, name = self.split_param_path(op)
+        if not name:
+            raise EditError("set needs 'param' (or a path ending in the parameter name)")
+        if "value" not in op:
+            raise EditError("set needs 'value'")
+        value = op["value"]
+        g = self.container(path)
+        pd = None
+        try:
+            pd = self.child_def(g[0], name, "parameter")
+        except EditError:
+            if self.p.defs:
+                raise
+        existing = [(e, pv) for e in g for pv in e.params if pv.name == name]
+        if isinstance(value, list):
+            if pd is None:
+                raise EditError("multi-value set needs the param defs loaded")
+            if pd.upper is not None and len(value) > pd.upper:
+                raise EditError(f"{pd.name} allows at most {pd.upper} value(s)")
+            for v in value:
+                self.check(pd, v)
+            for _ in existing:
+                e, pv = [(e, pv) for e in self.container(path) for pv in e.params if pv.name == name][0]
+                self.remove_node(e.file, pv.node)
+            for v in value:
+                self._add_value(path, pd, v)
+            return
+        if len(existing) > 1:
+            raise EditError(f"{name} has {len(existing)} values; pass a list to replace them, or use add/remove")
+        if pd is not None:
+            self.check(pd, value)
+        if not existing:
+            if pd is None:
+                raise EditError(f"{name} not present and no param defs loaded to create it")
+            self._add_value(path, pd, value)
+            return
+        e, pv = existing[0]
+        text = from_json(pd, value)
+        vn = pv.value_node
+        if pv.is_auto:
+            self.notes.append(f"{path}/{name} has IS-AUTO-VALUE=true; the generator may recompute it")
+        if vn is None:
+            raise EditError(f"{name} value element has no VALUE; remove and re-add it")
+        if vn.tag == "VALUE-REF":
+            dest = self.ref_dest(pd, text)
+            if vn.attrs.get("DEST") != dest or vn.cstart is None:
+                self.patch(e.file, vn.start, vn.end, f'<VALUE-REF DEST="{dest}">{escape(text)}</VALUE-REF>'.encode())
+                return
+        if vn.cstart is None:
+            self.patch(e.file, vn.start, vn.end, f"<{vn.tag}>{escape(text)}</{vn.tag}>".encode())
+        else:
+            self.patch(e.file, vn.cstart, vn.cend, escape(text).encode("utf-8"))
+
+    def _add_value(self, path: str, pd: D.DefNode, value):
+        e = self.container(path)[0]
+        coll = "REFERENCE-VALUES" if D.is_ref_kind(pd.kind or "") else "PARAMETER-VALUES"
+        self.insert_into(e.file, e.node, coll, [self.render_param(pd, f"{e.def_ref}/{pd.name}", value)])
+
+    def op_add(self, op: dict):
+        path = op.get("path", "").rstrip("/")
+        if op.get("param"):
+            g = self.container(path)
+            pd = self.child_def(g[0], op["param"], "parameter")
+            have = sum(1 for e in g for pv in e.params if pv.name == pd.name)
+            if pd.upper is not None and have >= pd.upper:
+                raise EditError(f"{pd.name} already has {have} value(s), def allows {pd.mult}; use set")
+            self.check(pd, op.get("value"))
+            self._add_value(path, pd, op.get("value"))
+            return
+        key = op.get("container")
+        if not key:
+            raise EditError("add needs 'container' (\"DefName:ShortName\") or 'param' + 'value'")
+        dname, _, sname = key.partition(":")
+        sname = sname or dname
+        g = self.container(path)
+        cd = self.child_def(g[0], dname, "container")
+        new_path = f"{path}/{sname}"
+        if self.p.find(new_path):
+            raise EditError(f"{new_path} already exists")
+        siblings = sum(1 for e in g for c in e.children if (c.def_ref or "").rsplit("/", 1)[-1] == cd.name)
+        if cd.upper is not None and siblings >= cd.upper:
+            raise EditError(f"{cd.name} already has {siblings} instance(s), def allows {cd.mult}")
+        e = g[0]
+        lines = self.render_container(e.file, cd, f"{e.def_ref}/{cd.name}", sname, op.get("values") or {})
+        coll = "CONTAINERS" if e.kind == "module" else "SUB-CONTAINERS"
+        self.insert_into(e.file, e.node, coll, [lines])
+
+    def op_remove(self, op: dict):
+        path, name = self.split_param_path(op)
+        if name and not self.p.find(f"{path}/{name}"):
+            g = self.container(path)
+            want = from_json(None, op["value"]) if "value" in op else None
+            hits = [(e, pv) for e in g for pv in e.params if pv.name == name and (want is None or pv.value == want)]
+            if not hits:
+                raise EditError(f"no value of {name}{'=' + want if want else ''} under {path}")
+            for _ in hits:
+                e, pv = [(e, pv) for e in self.container(path) for pv in e.params
+                         if pv.name == name and (want is None or pv.value == want)][0]
+                self.remove_node(e.file, pv.node)
+            return
+        target = f"{path}/{name}" if name else path
+        g = self.container(target)
+        refs_in = [p for p, grp in self.p.by_path.items() for e in grp for pv in e.params
+                   if pv.is_ref and pv.value == target]
+        if refs_in:
+            self.notes.append(f"{target} is still referenced from {', '.join(sorted(set(refs_in))[:10])}; "
+                              "validate will report dangling refs")
+        for _ in range(len(g)):
+            e = self.container(target)[0]
+            self.remove_node(e.file, e.node)
+
+    # ---------- results ----------
+    def diffs(self) -> list:
+        out = []
+        for f, before in self.original.items():
+            after = self.data(f)
+            if before == after:
+                continue
+            a = before.decode("utf-8", "replace").splitlines(keepends=True)
+            b = after.decode("utf-8", "replace").splitlines(keepends=True)
+            rel = self.p.rel(f)
+            out.append({"file": rel, "diff": "".join(difflib.unified_diff(a, b, f"a/{rel}", f"b/{rel}", n=2))})
+        return out
+
+    def write(self):
+        for f, before in self.original.items():
+            after = self.data(f)
+            if before != after:
+                tmp = f + ".ecuc-tmp"
+                with open(tmp, "wb") as fh:
+                    fh.write(after)
+                os.replace(tmp, f)
+
+
+OP_KEYS = {"op", "path", "param", "value", "container", "values"}
+
+
+def check_ops(ops) -> None:
+    """Shape-check ops before touching anything: clear errors instead of tracebacks."""
+    if not isinstance(ops, list) or not ops:
+        raise EditError(f"ops must be a non-empty list of op objects, got {type(ops).__name__}")
+    for i, op in enumerate(ops):
+        if not isinstance(op, dict):
+            raise EditError(f"op {i} must be an object like {{\"op\": \"set\", \"path\": ..., \"param\": ..., \"value\": ...}}, "
+                            f"got {type(op).__name__}: {str(op)[:120]}")
+        unknown = set(op) - OP_KEYS
+        if unknown:
+            raise EditError(f"op {i}: unknown key(s) {sorted(unknown)}; allowed: {sorted(OP_KEYS)}")
+        if op.get("op") not in ("set", "add", "remove"):
+            raise EditError(f"op {i}: 'op' must be set, add or remove (got {op.get('op')!r})")
+        if not isinstance(op.get("path"), str) or not op["path"].startswith("/"):
+            raise EditError(f"op {i}: 'path' must be an absolute AUTOSAR path string ('/Pkg/Module/...'), got {op.get('path')!r}")
+        for k in ("param", "container"):
+            if k in op and op[k] is not None and not isinstance(op[k], str):
+                raise EditError(f"op {i}: '{k}' must be a string, got {type(op[k]).__name__}")
+        if "values" in op and op["values"] is not None and not isinstance(op["values"], dict):
+            raise EditError(f"op {i}: 'values' must be an object of ECUC JSON, got {type(op['values']).__name__}")
+        if op["op"] == "set" and "value" not in op:
+            raise EditError(f"op {i}: set needs 'value'")
+        if op["op"] == "add" and not op.get("container") and not op.get("param"):
+            raise EditError(f"op {i}: add needs 'container' (\"DefName:ShortName\") or 'param' + 'value'")
+
+
+def schema_check(path: str, data: bytes) -> Optional[str]:
+    """Strict schema load with autosar-data when available. Returns an error string or None."""
+    try:
+        import autosar_data as ad  # type: ignore
+    except Exception:
+        return None
+    try:
+        m = ad.AutosarModel()
+        m.load_buffer(data.decode("utf-8"), os.path.basename(path), True)
+        return None
+    except Exception as e:  # noqa: BLE001
+        return str(e)
+
+
+def edit(project: Project, ops: list, dry_run: bool = False, force: bool = False, run_validate: bool = True) -> dict:
+    ed = Editor(project)
+    try:
+        ed.apply(ops, force=force)
+    except EditError as e:
+        return {"ok": False, "error": str(e), "written": False}
+    changes = ed.diffs()
+    res: dict = {"ok": True, "applied": len(ops), "changes": changes, "written": False}
+    schema = []
+    for f, before in ed.original.items():
+        if schema_check(f, before) is None:
+            err = schema_check(f, ed.data(f))
+            if err:
+                schema.append({"file": project.rel(f), "error": err})
+    if schema and not force:
+        return {"ok": False, "error": "edit would make the ARXML schema-invalid; nothing written",
+                "schema": schema, "changes": changes, "written": False}
+    if not dry_run:
+        ed.write()
+        res["written"] = True
+    if ed.notes:
+        res["notes"] = ed.notes
+    if run_validate:
+        touched = list(ed.original)
+        v = validate(project, files=touched)
+        res["validation"] = {"validated": v["validated"], "summary": v["summary"],
+                             "diagnostics": v["diagnostics"][:50]}
+    return res