riskrails 4.1.0 → 4.3.0

package/skills/project-update/rr_update/weights.py

@@ -0,0 +1,171 @@
+"""The weight files: the effective table, weight.md, and the one-time split of the mixed testing.md and weight.json.
+
+shell: effective_weight, weight_md, split_weight, unwritten, split_once
+core: GENERATED_HEADER, FIELD_LINE, SPECIFICS_RE, split_testing, leaves, listed
+"""
+
+import json
+import os
+import re
+import tempfile
+from collections import OrderedDict
+
+from rr_update import files
+from rr_update import paths
+from rr_update import plan as plan_mod
+from rr_update import siblings
+
+
+def effective_weight(plan):
+    """The weight table as this run leaves it: the plugin's with weight.project.json laid over it."""
+    own = plan.read(paths.WEIGHT_PROJECT)
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "weight.project.json")
+        if own is not None:
+            with open(path, "wb") as fh:
+                fh.write(own)
+        return siblings.weight_overlay().load(siblings.shipped_weight(), path)
+
+
+GENERATED_HEADER = b"generated by `state.py weight --mirror`"
+
+
+def weight_md(plan, history):
+    """weight.md is always rendered from the shipped table and the overlay (spec :161). A file that is
+    a rendering or a shipped version is replaced; one a human wrote is gated."""
+    try:
+        theirs = siblings.weight_module().mirror(effective_weight(plan)).encode("utf-8")
+    except (ValueError, OSError, KeyError, TypeError, AttributeError, RecursionError) as exc:
+        plan.hints.append("%s: not rendered (%s: %s); fix %s, then run this again"
+                          % (paths.WEIGHT_MD, type(exc).__name__, exc, paths.WEIGHT_PROJECT))
+        return
+    ours = plan.read(paths.WEIGHT_MD)
+    if ours is None:
+        plan.add("create", paths.WEIGHT_MD, "rendered from the weight table", content=theirs)
+    elif ours == theirs:
+        return
+    elif GENERATED_HEADER in ours[:600] or history.shipped("ai-init/" + paths.WEIGHT_MD, ours):
+        plan.add("regenerate", paths.WEIGHT_MD, "rendered from the weight table", content=theirs)
+    else:
+        plan.gated("regenerate", paths.WEIGHT_MD, plan_mod.edited_note(plan, paths.WEIGHT_MD, ours, theirs), content=theirs)
+
+
+# ---------------------------------------------------------------- the one-time split
+FIELD_LINE = re.compile(r"(?:%s):" % "|".join(
+    ("verify_command", "step_test_command", "e2e_command", "lint_command", "typecheck_command",
+     "single_test", "doc_tests", "bite_codes", "healthy_output", "runtime")))
+
+
+SPECIFICS_RE = re.compile(r"(?m)^## Project specifics[ \t]*$")
+
+
+def split_testing(testing, template):
+    """R11: verification.md from testing.md. The field lines are copied verbatim with their continuation
+    lines (indented, after a field line), then `## Project specifics` to the end of the file."""
+    lines = testing.decode("utf-8").splitlines(keepends=True)
+    fields, taking = [], False
+    for line in lines:
+        if FIELD_LINE.match(line):
+            fields.append(line)
+            taking = True
+        elif taking and line[:1] in (" ", "\t") and line.strip():
+            fields.append(line)
+        else:
+            taking = False
+    text = template.decode("utf-8")
+    if not fields:
+        return template, 0
+    head = text[:re.search(r"(?m)^verify_command:", text).start()]
+    tail = SPECIFICS_RE.search(testing.decode("utf-8"))
+    specifics = testing.decode("utf-8")[tail.start():] if tail else text[SPECIFICS_RE.search(text).start():]
+    body = "".join(fields)
+    return (head + body + ("" if body.endswith("\n") else "\n") + "\n" + specifics).encode("utf-8"), len(fields)
+
+
+def leaves(value, prefix=()):
+    """{path tuple: leaf} — objects are walked, a list or scalar (or an empty object) is one leaf."""
+    if isinstance(value, dict) and value:
+        out = {}
+        for k, v in value.items():
+            out.update(leaves(v, prefix + (k,)))
+        return out
+    return {prefix: value}
+
+
+def split_weight(old, history, template):
+    """R11: weight.project.json from the old weight.json: the leaves that differ from that leaf in every
+    version the plugin shipped (lists whole). -> (bytes, carried paths, uncarried paths that differ from today's table)."""
+    mine = json.loads(old.decode("utf-8"), object_pairs_hook=OrderedDict)
+    tables = []
+    for blob in history.versions("ai-init/" + paths.WEIGHT_JSON) + [files.read(siblings.shipped_weight())]:
+        try:
+            tables.append(leaves(json.loads(blob.decode("utf-8"))))
+        except (ValueError, RecursionError):
+            continue
+    today = tables[-1] if tables else {}
+    carried, uncarried = OrderedDict(), []
+    for path, value in leaves(mine).items():
+        if path[:1] in (("version",), ("_comment",)) or not path:
+            continue
+        if any(path in t and t[path] == value for t in tables):
+            if today.get(path, ...) != value:
+                uncarried.append(".".join(map(str, path)))
+            continue
+        here = carried
+        for part in path[:-1]:
+            here = here.setdefault(part, OrderedDict())
+        here[path[-1]] = value
+    doc = json.loads(template.decode("utf-8"), object_pairs_hook=OrderedDict)
+    doc.update(carried)
+    leaf_paths = [".".join(map(str, p)) for p in leaves(carried) if p]
+    return files.dump_json(doc), leaf_paths, uncarried
+
+
+def listed(names, limit=6):
+    shown = ", ".join(names[:limit])
+    return shown + (" and %d more" % (len(names) - limit) if len(names) > limit else "")
+
+
+def unwritten(plan, history, target, template):
+    """True when the new file is absent, or is still a shipped template (today's or any in the history index):
+    a scaffold run over an old tree can leave one, and it carries nothing of the project."""
+    if not plan.exists(target):
+        return True
+    data = plan.read(target)
+    return data is not None and (data.replace(b"\r\n", b"\n") == template.replace(b"\r\n", b"\n")
+                                 or history.shipped("ai-init/" + target, data))
+
+
+def split_once(plan, history):
+    """R11: when verification.md / weight.project.json are absent (or only a shipped template), make them from
+    testing.md / weight.json (once); with a project's own file present the old file is not read again.
+    The old weight.json is then REMOVED, gated."""
+    tpl = paths.TEMPLATES["ai-init"]
+    template = files.read(os.path.join(tpl, paths.VERIFICATION_MD))
+    if unwritten(plan, history, paths.VERIFICATION_MD, template):
+        absent = not plan.exists(paths.VERIFICATION_MD)
+        testing = plan.read(paths.TESTING_MD)
+        content, count = split_testing(testing, template) if testing is not None else (template, 0)
+        if count:
+            plan.add("split", paths.VERIFICATION_MD, "%d command line(s) of testing.md copied verbatim, with its "
+                     "Project specifics" % count, content=content)
+        elif absent:
+            plan.add("create", paths.VERIFICATION_MD, content=content)
+    template = files.read(os.path.join(tpl, paths.WEIGHT_PROJECT))
+    if unwritten(plan, history, paths.WEIGHT_PROJECT, template):
+        absent = not plan.exists(paths.WEIGHT_PROJECT)
+        old = plan.read(paths.WEIGHT_JSON)
+        if old is None:
+            if absent:
+                plan.add("create", paths.WEIGHT_PROJECT, content=template)
+        else:
+            content, carried, uncarried = split_weight(old, history, template)
+            if absent or content != plan.read(paths.WEIGHT_PROJECT):
+                note = "%d leaf/leaves of weight.json that differ from the plugin's table carried (%s)" % (
+                    len(carried), listed(carried) or "none")
+                if uncarried:
+                    note += "; %d not carried, equal to an older shipped value: %s" % (len(uncarried), listed(uncarried))
+                plan.add("split", paths.WEIGHT_PROJECT, note, content=content)
+    if plan.exists(paths.WEIGHT_JSON):
+        why = "[split] superseded by %s; the plugin's table is read from the plugin" % paths.WEIGHT_PROJECT
+        plan.gated("delete", paths.WEIGHT_JSON, why, reason=why)