@r1z4x/tezgah 1.9.2 → 1.13.0

package/bin/tezgah-review-quote

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""tezgah-review-quote - place review findings on the diff by their quoted code.
+
+    tezgah-review-quote [--repo DIR] --from BASE [--to HEAD] FINDINGS_JSON
+
+FINDINGS_JSON is a file (or `-` for stdin) holding a JSON list of objects with
+at least `path` and `quote`. Prints that list with `status` added:
+`located` (the quote is in its own file), `relocated` (it is nowhere in its own
+file but exactly once in another changed file; `path` moves there) or
+`unlocated`; a placed finding gets `start_line`/`end_line`, plus `side: "old"`
+when the lines are pre-change. A quote found several times in its own file is
+placed on the match covering the finding's own `start_line`, else it is
+`unlocated` with `reason: "ambiguous: N matches"`.
+
+A Python port of the deterministic comment positioning in
+alibaba/open-code-review (internal/diff/resolver.go: ResolveComment,
+RelocateAcrossFiles; Apache-2.0): each line is trimmed, one leading `+` then
+`-` marker is stripped, blank quote lines are dropped, and the quote must match
+consecutive lines - the hunks' new side, then their old side, then the whole
+new file (where blank file lines are skipped too). Unlike OCR, which takes the
+first match, every match is collected so a repeated quote is never placed on
+the wrong copy; a cited line only chooses among the quote's matches.
+"""
+import argparse
+import json
+import subprocess
+import sys
+
+
+def norm(line):
+    return line.strip().removeprefix("+").removeprefix("-").strip()
+
+
+def quote_lines(text):
+    return [n for n in map(norm, text.split("\n")) if n]
+
+
+def git(repo, *args):
+    return subprocess.run(["git", "-C", repo, *args], capture_output=True,
+                          text=True, errors="replace")
+
+
+def strip_prefix(path):
+    # ponytail: C-quoted paths (tabs, quotes in names) are not unquoted
+    if path == "/dev/null":
+        return None
+    return path[2:] if path[:2] in ("a/", "b/") else path
+
+
+def parse_diff(text):
+    """One dict per changed file: old/new path and the hunks' two sides as
+    [(line_number, normalised_text, removed)] lists, one pair per hunk."""
+    files, cur, old_no, new_no = [], None, 0, 0
+    for line in text.split("\n"):
+        if line.startswith("diff --git "):
+            cur = {"old": None, "new": None, "hunks": []}
+            files.append(cur)
+        elif cur is None:
+            continue
+        elif line.startswith("--- ") and not cur["hunks"]:
+            cur["old"] = strip_prefix(line[4:].rstrip("\t"))
+        elif line.startswith("+++ ") and not cur["hunks"]:
+            cur["new"] = strip_prefix(line[4:].rstrip("\t"))
+        elif line.startswith("@@"):
+            spans = line.split("@@")[1].split()
+            old_no = int(spans[0][1:].split(",")[0])
+            new_no = int(spans[1][1:].split(",")[0])
+            cur["hunks"].append(([], []))
+        elif cur["hunks"] and not line.startswith("\\"):
+            new_side, old_side = cur["hunks"][-1]
+            mark, body = line[:1], norm(line[1:])
+            if mark in (" ", ""):
+                new_side.append((new_no, body, False))
+                old_side.append((old_no, body, False))
+                new_no += 1
+                old_no += 1
+            elif mark == "+":
+                new_side.append((new_no, body, False))
+                new_no += 1
+            elif mark == "-":
+                old_side.append((old_no, body, True))
+                old_no += 1
+    return files
+
+
+def matches(side, target):
+    """Every consecutive run of `target` in `side`: (start, end, run)."""
+    n = len(target)
+    return [(side[i][0], side[i + n - 1][0], side[i:i + n])
+            for i in range(len(side) - n + 1)
+            if all(side[i + j][1] == target[j] for j in range(n))]
+
+
+def resolve(f, target, content):
+    """Every distinct (start, end, side) of `target` in one changed file: the
+    hunks' new side, their old side, then the whole new file."""
+    hits = [(s, e, "new") for hunk in f["hunks"] for s, e, _ in matches(hunk[0], target)]
+    # an old-side run of context lines only repeats a new-side one
+    hits += [(s, e, "old") for hunk in f["hunks"]
+             for s, e, run in matches(hunk[1], target) if any(p[2] for p in run)]
+    if content is not None:
+        lines = [(i, norm(t.rstrip("\r")))
+                 for i, t in enumerate(content.split("\n"), 1)]
+        hits += [(s, e, "new") for s, e, _ in matches([p for p in lines if p[1]], target)]
+    return list(dict.fromkeys(hits))
+
+
+def cited(finding):
+    try:
+        return int(finding.get("start_line"))
+    except (TypeError, ValueError):
+        return None
+
+
+def place(finding, f, hit):
+    out = dict(finding, path=f["new"] or f["old"],
+               start_line=hit[0], end_line=hit[1])
+    out.pop("side", None)
+    if hit[2] == "old":
+        out["side"] = "old"
+    return out
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="tezgah-review-quote")
+    ap.add_argument("--repo", default=".")
+    ap.add_argument("--from", dest="base", required=True)
+    ap.add_argument("--to", default="HEAD")
+    ap.add_argument("findings")
+    a = ap.parse_args(argv)
+    try:
+        src = sys.stdin if a.findings == "-" else open(a.findings, encoding="utf-8")
+        with src:
+            findings = json.load(src)
+        if not isinstance(findings, list) or not all(
+                isinstance(x, dict) and "path" in x and "quote" in x for x in findings):
+            raise ValueError("expected a JSON list of objects with path and quote")
+    except (OSError, ValueError) as e:
+        print(f"tezgah-review-quote: {a.findings}: {e}", file=sys.stderr)
+        return 2
+    diff = git(a.repo, "diff", "--no-ext-diff", "--no-textconv", "--no-color",
+               "--src-prefix=a/", "--dst-prefix=b/", "-U3", a.base, a.to)
+    if diff.returncode != 0:
+        print(f"tezgah-review-quote: git diff: {diff.stderr.strip()}", file=sys.stderr)
+        return 2
+    files, contents = parse_diff(diff.stdout), {}
+
+    def content(f):
+        if f["new"] and f["new"] not in contents:
+            r = git(a.repo, "show", f"{a.to}:{f['new']}")
+            contents[f["new"]] = r.stdout if r.returncode == 0 else None
+        return contents.get(f["new"])
+
+    out = []
+    for finding in findings:
+        target = quote_lines(str(finding["quote"] or ""))
+        own = [f for f in files if finding["path"] in (f["new"], f["old"])]
+        mine = resolve(own[0], target, content(own[0])) if target and own else []
+        line = cited(finding)
+        covering = [h for h in mine if line is not None and h[0] <= line <= h[1]]
+        # OCR's order: the new side wins over the old one, so a whitespace-only
+        # change matching on both sides is one new-side hit, not an ambiguity
+        new = [h for h in mine if h[2] == "new"]
+        pick = covering or (new if len(new) == 1 else []) or (mine if len(mine) == 1 else [])
+        if pick:
+            out.append(dict(place(finding, own[0], pick[0]), status="located"))
+            continue
+        if mine:
+            out.append(dict(finding, status="unlocated",
+                            reason=f"ambiguous: {len(new) or len(mine)} matches"))
+            continue
+        hits = [] if not target else [
+            (f, h) for f in files if f not in own
+            for h in resolve(f, target, content(f))]
+        if len(hits) == 1:
+            out.append(dict(place(finding, *hits[0]), status="relocated"))
+        else:
+            out.append(dict(finding, status="unlocated"))
+    json.dump(out, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())