116 lines
5.5 KiB
Python
116 lines
5.5 KiB
Python
"""Record what a chunk's items were predicted to touch beside what its branch touched.
|
|
|
|
usage: touch-predictions record <ID>...
|
|
|
|
Run it in the chunk's worktree, on the chunk's branch, with every review fix committed and before
|
|
`todo-item finish` removes the items; <ID>... are the plan items the chunk takes. It reads each
|
|
item's prediction from its detail in the project's plan: the bullets under a `Touches:` line, one
|
|
per file, as in
|
|
|
|
Touches:
|
|
|
|
- `bin/a.py`: `main`, `Plan.branch` (small)
|
|
- `README.md`: `## Goals`
|
|
- `bin/run.sh`: lines 10-20
|
|
- `docs/new.md`
|
|
|
|
A path alone is the whole file, and (small) marks a part the item changes only a little. A path or
|
|
a name that holds a backtick takes a longer run of backticks with a space inside each end, as a
|
|
Markdown code span does: `` ## The `foo` tool ``. It names what the branch touched the same way,
|
|
from the diff between the branch's merge base with the default branch and HEAD:
|
|
|
|
- in a .py file, by Python's `ast` module: the innermost function or class a changed line lies in,
|
|
named with those around it; a top-level assignment by the name it sets; `(module)` for any other
|
|
top-level line. A comment between two statements goes with the one below it;
|
|
- in a .md file, by the nearest heading above the line, outside fenced code, spelt as its line;
|
|
`(top)` before the first heading;
|
|
- in any other file, and in Python that doesn't parse, by the line ranges the diff changed, as they
|
|
stand at HEAD;
|
|
- a file the branch added or deleted, or changed without text hunks, as the path alone. A rename
|
|
reads as a file deleted and one added.
|
|
|
|
A changed blank line names no part where the file has other changed lines, unless it lies inside a
|
|
Python statement.
|
|
|
|
It leaves out the plan and the project's records, which every chunk writes. It appends
|
|
`## Chunk <IDs>, <UTC time>, at <commit>`, the IDs in rising order, with both lists to the record
|
|
the project's config names as `touch-predictions`, in place of an entry the record already holds
|
|
for the same items. Commit the record with the chunk. Where the config leaves the setting out, it
|
|
says so and exits 0.
|
|
|
|
Exit 1, saying why: on any other arguments; when no config names the checkout; when the plan or
|
|
the record cannot be read or written; when the plan holds no item <ID>; when a `Touches:` list
|
|
cannot be read; or when git cannot name the merge base or the diff.
|
|
"""
|
|
import sys
|
|
import time
|
|
import typing
|
|
|
|
from git_cli.git_repo import default_ref, git, Git
|
|
from failure import Failure
|
|
from plan_store.stores import store as plan_store
|
|
from touch_predictions.prediction import predicted, together, Touches
|
|
from project_config.main import project
|
|
from project_config.settings import ProjectConfig, TOUCH_PREDICTIONS
|
|
from touch_predictions import record
|
|
from record_store.stores import RECORDS, touch_predictions_store
|
|
from touch_predictions.diff_parts import touched
|
|
from text_files.utc_stamp import utc
|
|
|
|
|
|
def main(argv: list[str]) -> int:
|
|
if argv[:1] in (["-h"], ["--help"]):
|
|
print(__doc__.strip())
|
|
return 0
|
|
if argv[:1] != ["record"] or len(argv) < 2 or not all(id_.isascii() and id_.isdigit() for id_ in argv[1:]):
|
|
print("usage: touch-predictions record <ID>...", file=sys.stderr)
|
|
return 1
|
|
config = project()
|
|
done = config if isinstance(config, Failure) else recorded(config, sorted({int(id_) for id_ in argv[1:]}))
|
|
if isinstance(done, Failure):
|
|
print(f"touch-predictions: {done.reason}", file=sys.stderr)
|
|
return 1
|
|
print(done)
|
|
return 0
|
|
|
|
|
|
def recorded(config: ProjectConfig, ids: list[int], now: typing.Callable[[], float] = time.time, run: Git = git) -> str | Failure:
|
|
"""Appends the entry of the chunk that takes the items ids, stamped at now and read from the commits run shows, and says so; or says that the project keeps no record."""
|
|
store = touch_predictions_store(config)
|
|
if store is None:
|
|
return f"The project's config sets no `{TOUCH_PREDICTIONS}`, so nothing is recorded."
|
|
prediction = predictions(config, ids)
|
|
if isinstance(prediction, Failure):
|
|
return prediction
|
|
cwd = str(config.top)
|
|
default = default_ref(cwd, run=run)
|
|
base = default if isinstance(default, Failure) else run("merge-base", default, "HEAD", cwd=cwd)
|
|
head = base if isinstance(base, Failure) else run("rev-parse", "--short", "HEAD", cwd=cwd)
|
|
if isinstance(base, Failure) or isinstance(head, Failure):
|
|
return head if isinstance(head, Failure) else base
|
|
# Every chunk writes the plan and the records, so they are left out of what a chunk touched.
|
|
skipped = {path for name in ("plan", *RECORDS, TOUCH_PREDICTIONS) if (path := config.tracked(name))}
|
|
touches = touched(base.strip(), "HEAD", cwd, skipped, run)
|
|
if isinstance(touches, Failure):
|
|
return touches
|
|
failed = record.append(store, ids, record.entry(ids, utc(now()), head.strip(), prediction, touches))
|
|
return failed or f"Recorded what chunk {', '.join(map(str, ids))} was predicted to touch, and what it touched, in {store.label}."
|
|
|
|
|
|
def predictions(config: ProjectConfig, ids: list[int]) -> Touches | None | Failure:
|
|
"""What the items ids predict between them; None where none of them predicts anything."""
|
|
plan = plan_store(config).read()
|
|
if isinstance(plan, Failure):
|
|
return plan
|
|
details = {item.id: item.detail for item in plan.items}
|
|
found = []
|
|
for id_ in ids:
|
|
if id_ not in details:
|
|
return Failure(f"the plan holds no item {id_}")
|
|
prediction = predicted(details[id_])
|
|
if isinstance(prediction, Failure):
|
|
return Failure(f"item {id_}: {prediction.reason}")
|
|
if prediction is not None:
|
|
found.append(prediction)
|
|
return together(found) if found else None
|