59 lines
2.7 KiB
Python
59 lines
2.7 KiB
Python
"""Open one of a project's records as a file to read and edit, and save the edit.
|
|
|
|
usage: project-record open <record>
|
|
project-record save <record>
|
|
|
|
Run inside a checkout, or a worktree of one. <record> is one of decisions, score-anchors,
|
|
comprehension-history, reading-cost and changelog, each kept where the project's config names it.
|
|
|
|
open prints the path of a file holding the record's text, and nothing else. Read and edit that
|
|
file. Where the record is kept as a file, the path is that file. Where it is kept elsewhere, the
|
|
path is a copy under ~/.local/state/project-record/<key>/, written afresh with the record as it
|
|
stands, so open it again before each edit. A record that doesn't exist yet has no file at the path:
|
|
create it there.
|
|
|
|
save stores the file's text in the record, and prints one line saying so. Where the record is kept
|
|
as a file there is nothing left to store, and it says that. Run it after every edit, so the same
|
|
steps work wherever a project keeps the record.
|
|
|
|
Exit 2 on bad arguments, and 1, saying why, on any other failure.
|
|
"""
|
|
import pathlib
|
|
import sys
|
|
|
|
from failure import Failure
|
|
from record_store.stores import FileStore, local_file, RECORDS, RecordStore, store, stored
|
|
from project_config.main import located
|
|
|
|
# Three readers, seated as the human and as the agents that follow the rules, picked the spelling from five candidates: git's verbs, such as checkout and commit, or pull and push, read as acting on the repo.
|
|
COMMANDS = ("open", "save")
|
|
# Where the copy of a record kept outside files goes, under the user's home, in a folder per project.
|
|
COPIES = ".local/state/project-record"
|
|
|
|
|
|
def main(argv: list[str]) -> int:
|
|
if argv[:1] in (["-h"], ["--help"]):
|
|
print(__doc__.strip())
|
|
return 0
|
|
if len(argv) != 2 or argv[0] not in COMMANDS or argv[1] not in RECORDS:
|
|
print(f"usage: project-record {'|'.join(COMMANDS)} <record>, where <record> is one of {', '.join(RECORDS)}", file=sys.stderr)
|
|
return 2
|
|
home = pathlib.Path.home()
|
|
config = located(None, home)
|
|
done = config if isinstance(config, Failure) else act(argv[0], store(config, argv[1]), home / COPIES / config.key / f"{argv[1]}.md")
|
|
if isinstance(done, Failure):
|
|
print(f"project-record: {done.reason}", file=sys.stderr)
|
|
return 1
|
|
print(done)
|
|
return 0
|
|
|
|
|
|
def act(command: str, record: RecordStore, copy: pathlib.Path) -> str | Failure:
|
|
"""What command, one of COMMANDS, prints for record, whose copy goes at copy where it needs one."""
|
|
if command == "open":
|
|
opened = local_file(record, copy)
|
|
return opened if isinstance(opened, Failure) else str(opened)
|
|
if unstored := stored(record, copy):
|
|
return unstored
|
|
return f"{record.path} is the record itself, so nothing is left to store." if isinstance(record, FileStore) else f"Stored {copy} in {record.label}."
|