Added contributor(s) name(s) to ROADMAP.md sync scripts and updated ROADMAP.md to include changes in its "legend map".

Author: razorblade23

ROADMAP.md

@@ -5,6 +5,7 @@ This may be subject to change.
 `[ ]` - no work has been done
 `[ ] 🚧` - work in progress (assigned / open PR)
 `[x]` - lesson completed
+`👤 name` - who is working on issue
 
 ## Roadmap
 1. Introduction

scripts/roadmap/reconcile_roadmap.py

@@ -17,15 +17,20 @@
 That covers the common paths (assigned, merged-and-closed) even for
 history that predates the automation.
 """
-
 import json
 import os
 import sys
 import urllib.error
 import urllib.request
 
 sys.path.insert(0, os.path.dirname(__file__))
-from sync_roadmap import LINE_RE, ROADMAP_PATH, apply_updates  # noqa: E402
+from sync_roadmap import (  # noqa: E402
+    LINE_RE,
+    ROADMAP_PATH,
+    Update,
+    apply_updates,
+    update_from_issue,
+)
 
 
 def find_linked_issues() -> set[int]:
@@ -53,14 +58,6 @@ def fetch_issue(repo: str, token: str, number: int) -> dict:
         return json.load(resp)
 
 
-def target_state(issue: dict) -> str:
-    if issue.get("state") == "closed":
-        return "x"
-    if issue.get("assignees"):
-        return "-"
-    return " "
-
-
 def main() -> None:
     repo = os.environ["GITHUB_REPOSITORY"]
     token = os.environ["GITHUB_TOKEN"]
@@ -70,17 +67,14 @@ def main() -> None:
         print("No linked issues found in ROADMAP.md.")
         return
 
-    updates: dict[int, str] = {}
+    updates: dict[int, Update] = {}
     for number in sorted(issue_numbers):
         try:
             issue = fetch_issue(repo, token, number)
         except urllib.error.HTTPError as e:
-            print(
-                f"#{number}: could not fetch issue ({e.code}) — skipping",
-                file=sys.stderr,
-            )
+            print(f"#{number}: could not fetch issue ({e.code}) — skipping", file=sys.stderr)
             continue
-        updates[number] = target_state(issue)
+        updates[number] = update_from_issue(issue)
 
     changed = apply_updates(updates)
     if not changed:
@@ -93,4 +87,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

scripts/roadmap/sync_roadmap.py

@@ -4,78 +4,100 @@
 change) and updates the matching line in ROADMAP.md to one of three
 states:
 
-    [ ] Lists — #34          not started
-    [ ] 🚧 Lists — #34        in progress (assigned / open PR)
-    [x] Lists — #34          done (merged / issue closed)
+    [ ] Lists — #34                       not started
+    [ ] 🚧 Lists — #34 👤 alice, bob       in progress (assigned / open PR)
+    [x] Lists — #34                       done (merged / issue closed)
 
 GitHub's task-list rendering only recognizes [ ] and [x] as real,
 interactive checkboxes — anything else (like a bare [-]) is just
 literal text with no checkbox widget. So the checkbox itself stays
 strictly boolean (done / not done), and "in progress" is layered on
 as a 🚧 badge in the visible text instead of a third bracket state.
 
+While a lesson is in progress, the issue's assignees are listed at the
+end of the line after a 👤 marker (plain usernames, no @ mentions).
+The names are dropped again once the lesson is done or unassigned.
+
 This only touches roadmap lines that already reference an issue, e.g.:
 
     * [ ] Lists — #34
 
 Lines with no "— #N" suffix are left alone — link an issue to a lesson
 by adding that suffix, and the automation picks it up from then on.
 """
-
 import json
 import os
 import re
+from typing import NamedTuple
 
 ROADMAP_PATH = "ROADMAP.md"
 WIP_BADGE = "🚧"
+ASSIGNEE_MARKER = "👤"
 
-# Internal state codes (unchanged from before): " " = not started,
-# "-" = in progress, "x" = done. Only how they're RENDERED changes.
+# Internal state codes: " " = not started, "-" = in progress, "x" = done.
+# Only how they're RENDERED matters to GitHub's markdown.
 STATE_RENDER = {
     " ": {"check": " ", "badge": ""},
     "-": {"check": " ", "badge": f"{WIP_BADGE} "},
     "x": {"check": "x", "badge": ""},
 }
 
-# Matches e.g. "    * [ ] 🚧 Lists — #34" and captures the checkbox,
-# an optional WIP badge, and the issue number — everything else on
-# the line is left untouched.
+# Matches e.g. "    * [ ] 🚧 Lists — #34 👤 alice" and captures the checkbox,
+# an optional WIP badge, and the issue number. `rest` is everything after
+# the issue number (including any assignee suffix, handled separately).
 LINE_RE = re.compile(
     r"^(?P<prefix>\s*\*\s*\[)(?P<check>[ x])(?P<mid>\]\s*)"
     rf"(?P<badge>{WIP_BADGE}\s*)?"
     r"(?P<body>.*?—\s*#)(?P<issue>\d+)(?P<rest>.*)$"
 )
 
+# The assignee suffix always sits at the very end of the line.
+ASSIGNEE_SUFFIX_RE = re.compile(rf"\s+{ASSIGNEE_MARKER}\s+.*$")
+
+# Matches "Closes #12", "Fixes #34", "Resolves #7", etc. (repeatable, case-insensitive)
+ISSUE_REF_RE = re.compile(r"(?:clos(?:e[sd]?)|fix(?:e[sd])?|resolve[sd]?)\s+#(\d+)", re.IGNORECASE)
+
+HANDLED_ISSUE_ACTIONS = {"assigned", "unassigned", "closed", "reopened"}
+
+
+class Update(NamedTuple):
+    state: str
+    # None = keep whatever names are already on the line. PR events use this,
+    # since a PR payload doesn't carry the linked issue's assignee list.
+    assignees: list[str] | None = None
+
 
 def current_state(check: str, badge: str | None) -> str:
     if check == "x":
         return "x"
     return "-" if badge else " "
 
 
-# Matches "Closes #12", "Fixes #34", "Resolves #7", etc. (repeatable, case-insensitive)
-ISSUE_REF_RE = re.compile(
-    r"(?:clos(?:e[sd]?)|fix(?:e[sd])?|resolve[sd]?)\s+#(\d+)", re.IGNORECASE
-)
+def state_for_issue(issue: dict) -> str:
+    if issue.get("state") == "closed":
+        return "x"
+    return "-" if issue.get("assignees") else " "
 
 
-def marker_for_issue_event(event: dict) -> dict[int, str]:
-    action = event["action"]
-    issue_number = event["issue"]["number"]
-
-    if action == "assigned":
-        return {issue_number: "-"}
-    if action == "unassigned":
-        return {issue_number: " "}
-    if action == "closed":
-        return {issue_number: "x"}
-    if action == "reopened":
-        has_assignee = bool(event["issue"].get("assignees"))
-        return {issue_number: "-" if has_assignee else " "}
-    return {}
+def assignee_logins(issue: dict) -> list[str]:
+    return [a["login"] for a in issue.get("assignees") or []]
+
+
+def update_from_issue(issue: dict) -> Update:
+    """Works for both webhook payloads and REST API issue objects."""
+    return Update(state_for_issue(issue), assignee_logins(issue))
+
+
+def updates_for_issue_event(event: dict) -> dict[int, Update]:
+    if event["action"] not in HANDLED_ISSUE_ACTIONS:
+        return {}
+    issue = event["issue"]
+    # The issue object reflects the state AFTER the change, so unassigning
+    # one of two people correctly leaves the line in progress.
+    return {issue["number"]: update_from_issue(issue)}
 
 
-def marker_for_pr_event(event: dict) -> dict[int, str]:
+def updates_for_pr_event(event: dict) -> dict[int, Update]:
     action = event["action"]
     pr = event["pull_request"]
     body = pr.get("body") or ""
@@ -84,63 +106,79 @@ def marker_for_pr_event(event: dict) -> dict[int, str]:
         return {}
 
     if action in ("opened", "ready_for_review"):
-        marker = "-"
+        update = Update("-")
     elif action == "closed":
-        marker = "x" if pr.get("merged") else "-"
+        update = Update("x") if pr.get("merged") else Update("-")
     else:
         return {}
 
-    return {n: marker for n in issue_numbers}
+    return {n: update for n in issue_numbers}
 
 
 def load_event() -> dict:
     with open(os.environ["GITHUB_EVENT_PATH"], encoding="utf-8") as f:
         return json.load(f)
 
 
-def compute_updates() -> dict[int, str]:
+def compute_updates() -> dict[int, Update]:
     event_name = os.environ["GITHUB_EVENT_NAME"]
     event = load_event()
 
     if event_name == "issues":
-        return marker_for_issue_event(event)
-    if event_name == "pull_request" or event_name == "pull_request_target":
-        return marker_for_pr_event(event)
+        return updates_for_issue_event(event)
+    if event_name in ("pull_request", "pull_request_target"):
+        return updates_for_pr_event(event)
     return {}
 
 
-def apply_updates(updates: dict[int, str]) -> bool:
+def render_suffix(update: Update, existing_suffix: str) -> str:
+    if update.state != "-":
+        return ""  # names are only shown while a lesson is in progress
+    if update.assignees is None:
+        return existing_suffix
+    if not update.assignees:
+        return ""
+    return f" {ASSIGNEE_MARKER} {', '.join(update.assignees)}"
+
+
+def apply_updates(updates: dict[int, Update]) -> bool:
     with open(ROADMAP_PATH, encoding="utf-8") as f:
         lines = f.readlines()
 
     changed = False
     for i, line in enumerate(lines):
-        m = LINE_RE.match(line.rstrip("\n"))
+        stripped = line.rstrip("\r\n")
+        eol = line[len(stripped):]
+
+        m = LINE_RE.match(stripped)
         if not m:
             continue
 
         issue = int(m.group("issue"))
         if issue not in updates:
             continue
 
-        new_state = updates[issue]
+        update = updates[issue]
         old_state = current_state(m.group("check"), m.group("badge"))
-        if old_state == new_state:
+        render = STATE_RENDER[update.state]
+
+        rest = m.group("rest")
+        existing = ASSIGNEE_SUFFIX_RE.search(rest)
+        rest_base = ASSIGNEE_SUFFIX_RE.sub("", rest)
+        suffix = render_suffix(update, existing.group(0) if existing else "")
+        if suffix:
+            rest_base = rest_base.rstrip()  # no double space before the 👤
+
+        new_line = (
+            m.group("prefix") + render["check"] + m.group("mid") + render["badge"]
+            + m.group("body") + m.group("issue") + rest_base + suffix + eol
+        )
+        if new_line == line:
             continue
 
-        render = STATE_RENDER[new_state]
-        lines[i] = (
-            m.group("prefix")
-            + render["check"]
-            + m.group("mid")
-            + render["badge"]
-            + m.group("body")
-            + m.group("issue")
-            + m.group("rest")
-            + "\n"
-        )
+        lines[i] = new_line
         changed = True
-        print(f"#{issue}: [{old_state}] -> [{new_state}]")
+        print(f"#{issue}: [{old_state}] -> [{update.state}]{suffix}")
 
     if changed:
         with open(ROADMAP_PATH, "w", encoding="utf-8") as f:
@@ -166,4 +204,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()