221 lines
7.7 KiB
Python
Executable File
221 lines
7.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Cut a new release: collect DONE items from Backlog into a new Version section.
|
|
|
|
Usage:
|
|
poetry run python scripts/release.py major
|
|
poetry run python scripts/release.py minor
|
|
"""
|
|
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
PROJECT_FILE = Path("PROJECT.org")
|
|
CHANGELOG_FILE = Path("CHANGELOG.org")
|
|
PYPROJECT_FILE = Path("pyproject.toml")
|
|
|
|
BACKLOG_RE = re.compile(r"^\* Backlog\s+\[(\d+)/(\d+)\](.*)$")
|
|
VERSION_RE = re.compile(r"^\* Version\s+(\d+\.\d+)\s+\[\d+/\d+\]")
|
|
ITEM_HEADER_RE = re.compile(r"^\*\* ")
|
|
|
|
|
|
def parse_done_line(line):
|
|
"""Extract a clean title from a ** DONE line, stripping priority and tags."""
|
|
rest = line[8:].strip() # remove "** DONE "
|
|
# strip priority marker like [#A]
|
|
rest = re.sub(r"^\[#[A-C]\]\s+", "", rest, count=1)
|
|
# strip org-mode tags at end (space-colon-tags)
|
|
rest = re.sub(r"\s+:\S.*:\s*$", "", rest)
|
|
return rest
|
|
|
|
|
|
def bump_version(current_major, current_minor, kind):
|
|
if kind == "major":
|
|
return current_major + 1, 0
|
|
elif kind == "minor":
|
|
return current_major, current_minor + 1
|
|
else:
|
|
raise ValueError(f"Unknown bump kind: {kind}")
|
|
|
|
|
|
def collect_done_items(backlog_lines):
|
|
"""Split Backlog into items; return done items and kept items.
|
|
|
|
Each item is a list of lines (without the section header).
|
|
"""
|
|
# Split Backlog into items at each ** line (skip the section header)
|
|
items = [] # list of (start_idx, end_idx, is_done)
|
|
item_start = None
|
|
for i in range(1, len(backlog_lines)):
|
|
if ITEM_HEADER_RE.match(backlog_lines[i]):
|
|
if item_start is not None:
|
|
items.append(
|
|
(item_start, i, backlog_lines[item_start].startswith("** DONE"))
|
|
)
|
|
item_start = i
|
|
if item_start is not None:
|
|
items.append(
|
|
(
|
|
item_start,
|
|
len(backlog_lines),
|
|
backlog_lines[item_start].startswith("** DONE"),
|
|
)
|
|
)
|
|
|
|
done_items = [backlog_lines[s:e] for s, e, is_done in items if is_done]
|
|
kept_items = [backlog_lines[s:e] for s, e, is_done in items if not is_done]
|
|
return done_items, kept_items
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 2 or sys.argv[1] not in ("major", "minor"):
|
|
print(f"Usage: {sys.argv[0]} <major|minor>", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
kind = sys.argv[1]
|
|
|
|
changelog_lines = CHANGELOG_FILE.read_text().splitlines(keepends=True)
|
|
project_lines = PROJECT_FILE.read_text().splitlines(keepends=True)
|
|
|
|
# ---------------------------------------------------------------
|
|
# 1. Parse current version from the first * Version header in CHANGELOG.org
|
|
# ---------------------------------------------------------------
|
|
version_start = None
|
|
for i, line in enumerate(changelog_lines):
|
|
if VERSION_RE.match(line.strip()):
|
|
version_start = i
|
|
break
|
|
|
|
if version_start is None:
|
|
print(
|
|
"ERROR: no parseable Version header found in CHANGELOG.org", file=sys.stderr
|
|
)
|
|
sys.exit(1)
|
|
|
|
vm = VERSION_RE.match(changelog_lines[version_start].strip())
|
|
current_version = vm.group(1)
|
|
major_str, minor_str = current_version.split(".")
|
|
current_major = int(major_str)
|
|
current_minor = int(minor_str)
|
|
new_major, new_minor = bump_version(current_major, current_minor, kind)
|
|
new_version = f"{new_major}.{new_minor}"
|
|
|
|
# ---------------------------------------------------------------
|
|
# 2. Identify the Backlog section in PROJECT.org
|
|
# ---------------------------------------------------------------
|
|
section_starts = []
|
|
for i, line in enumerate(project_lines):
|
|
if line.startswith("* ") and not line.startswith("** "):
|
|
section_starts.append(i)
|
|
section_starts.append(len(project_lines))
|
|
|
|
backlog_idx = None
|
|
for idx, start in enumerate(section_starts[:-1]):
|
|
if project_lines[start].strip().startswith("* Backlog"):
|
|
backlog_idx = idx
|
|
|
|
if backlog_idx is None:
|
|
print("ERROR: no Backlog section found in PROJECT.org", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
backlog_start = section_starts[backlog_idx]
|
|
backlog_end = section_starts[backlog_idx + 1]
|
|
backlog_lines = project_lines[backlog_start:backlog_end]
|
|
|
|
done_items, kept_items = collect_done_items(backlog_lines)
|
|
|
|
if not done_items:
|
|
print("No DONE items found in Backlog — nothing to release.")
|
|
sys.exit(1)
|
|
|
|
# ---------------------------------------------------------------
|
|
# 3. Build the new Version section text
|
|
# ---------------------------------------------------------------
|
|
version_section_lines = [
|
|
f"* Version {new_version} [{len(done_items)}/{len(done_items)}]\n"
|
|
]
|
|
for item in done_items:
|
|
version_section_lines.extend(item)
|
|
version_section_lines.append("\n")
|
|
|
|
# ---------------------------------------------------------------
|
|
# 4. Build updated Backlog section
|
|
# ---------------------------------------------------------------
|
|
backlog_header_line = backlog_lines[0]
|
|
bm = BACKLOG_RE.match(backlog_header_line.strip())
|
|
if not bm:
|
|
print(
|
|
f"ERROR: could not parse backlog header: {backlog_header_line!r}",
|
|
file=sys.stderr,
|
|
)
|
|
sys.exit(1)
|
|
tags = bm.group(3)
|
|
|
|
new_done = 0
|
|
new_total = len(kept_items)
|
|
new_backlog_header = f"* Backlog [{new_done}/{new_total}]{tags}\n"
|
|
|
|
backlog_body = []
|
|
for item in kept_items:
|
|
backlog_body.extend(item)
|
|
|
|
# ---------------------------------------------------------------
|
|
# 5. Assemble the new PROJECT.org (Backlog + DONE items removed)
|
|
# ---------------------------------------------------------------
|
|
before_backlog = project_lines[:backlog_start]
|
|
output_project = before_backlog + [new_backlog_header] + backlog_body
|
|
PROJECT_FILE.write_text("".join(output_project))
|
|
|
|
# ---------------------------------------------------------------
|
|
# 6. Insert the new Version section into CHANGELOG.org after the title
|
|
# ---------------------------------------------------------------
|
|
output_changelog = (
|
|
changelog_lines[:version_start]
|
|
+ version_section_lines
|
|
+ changelog_lines[version_start:]
|
|
)
|
|
CHANGELOG_FILE.write_text("".join(output_changelog))
|
|
|
|
# ---------------------------------------------------------------
|
|
# 7. Update pyproject.toml
|
|
# ---------------------------------------------------------------
|
|
pyproject = PYPROJECT_FILE.read_text()
|
|
pyproject = re.sub(
|
|
r'^version = "[\d.]+"',
|
|
f'version = "{new_version}"',
|
|
pyproject,
|
|
count=1,
|
|
flags=re.MULTILINE,
|
|
)
|
|
PYPROJECT_FILE.write_text(pyproject)
|
|
|
|
# ---------------------------------------------------------------
|
|
# 8. Build commit body from done item titles
|
|
# ---------------------------------------------------------------
|
|
commit_lines = []
|
|
for item in done_items:
|
|
title = parse_done_line(item[0])
|
|
if title:
|
|
commit_lines.append(f"- {title}")
|
|
|
|
commit_body = "\n".join(commit_lines)
|
|
commit_message = f"[release] Bump to version {new_version}\n\n{commit_body}"
|
|
|
|
# ---------------------------------------------------------------
|
|
# 9. Git commit + tag
|
|
# ---------------------------------------------------------------
|
|
subprocess.run(
|
|
["git", "add", str(PROJECT_FILE), str(CHANGELOG_FILE), str(PYPROJECT_FILE)],
|
|
check=True,
|
|
)
|
|
subprocess.run(["git", "commit", "-m", commit_message], check=True)
|
|
subprocess.run(["git", "tag", new_version], check=True)
|
|
|
|
print(f"\nReleased v{new_version} — tag {new_version} created.")
|
|
print(f"Moved {len(done_items)} DONE item(s) from Backlog to CHANGELOG.org.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|