Add Recent Files menu item

Author: python-processing-unit

src/morgul/app.py

@@ -90,19 +90,23 @@
 from morgul.password_ui import SetPasswordDialog, UnlockPasswordDialog
 from morgul.render import to_html
 from morgul.session import (
+    RECENT_LIMIT,
     SESSION_VERSION,
     SessionIndex,
     TabMeta,
     TabPayload,
     blob_is_encrypted,
+    clear_recent,
     clear_session,
     decode_tab_blob,
     encode_tab_blob,
     load_index,
+    load_recent,
     new_tab_id,
     prune_tab_blobs,
     read_tab_blob,
     save_index,
+    save_recent,
     write_tab_blob,
 )
 from morgul.syncmap import preview_pos_to_source, source_pos_to_preview
@@ -1605,6 +1609,7 @@ def __init__(self) -> None:
         self._find_dialog = FindReplaceDialog(self)
         self._wrap_action: QAction | None = None
         self._preview_action: QAction | None = None
+        self._recent = load_recent()
 
         self._build_menus()
         if not self._restore_session():
@@ -1648,6 +1653,8 @@ def _build_menus(self) -> None:
         file_menu.addAction(
             self._act("&Open...", QKeySequence.StandardKey.Open, self._open)
         )
+        self._recent_menu = file_menu.addMenu("Open &Recent")
+        self._rebuild_recent_menu()
         file_menu.addAction(
             self._act("&Save", QKeySequence.StandardKey.Save, self._save)
         )
@@ -2082,7 +2089,10 @@ def _open(self) -> None:
         )
         if not path_str:
             return
-        path = Path(path_str)
+        self._open_path(Path(path_str))
+
+    def _open_path(self, path: Path) -> None:
+        """Open *path*, falling back to the active blank tab when possible."""
         try:
             text, password = self._read_document(path)
         except MorgulFormatError as exc:
@@ -2106,8 +2116,54 @@ def _open(self) -> None:
         else:
             target = self._new_tab()
         target.load_text(text, path=path, password=password)
+        self._add_recent(path)
         self.tab_meta_changed()
 
+    def _rebuild_recent_menu(self) -> None:
+        """Repopulate the Open Recent submenu from ``self._recent``."""
+        self._recent_menu.clear()
+        if not self._recent:
+            empty = self._recent_menu.addAction("No recent files")
+            empty.setEnabled(False)
+            return
+        for path_str in self._recent:
+            action = self._recent_menu.addAction(path_str)
+            action.triggered.connect(lambda _=False, p=path_str: self._open_recent(p))
+        self._recent_menu.addSeparator()
+        clear = self._recent_menu.addAction("Clear Recent Files")
+        clear.triggered.connect(self._clear_recent)
+
+    def _add_recent(self, path: Path) -> None:
+        """Push *path* to the front of the recent list and persist it."""
+        entry = str(path)
+        with contextlib.suppress(ValueError):
+            self._recent.remove(entry)
+        self._recent.insert(0, entry)
+        del self._recent[RECENT_LIMIT:]
+        with contextlib.suppress(OSError):
+            save_recent(self._recent)
+        self._rebuild_recent_menu()
+
+    def _clear_recent(self) -> None:
+        """Empty the recent list and its menu."""
+        self._recent.clear()
+        with contextlib.suppress(OSError):
+            clear_recent()
+        self._rebuild_recent_menu()
+
+    def _open_recent(self, path_str: str) -> None:
+        """Open a file chosen from the Open Recent submenu."""
+        path = Path(path_str)
+        if not path.is_file():
+            QMessageBox.warning(self, "Morgul", f"File not found:\n{path}")
+            if path_str in self._recent:
+                self._recent.remove(path_str)
+                with contextlib.suppress(OSError):
+                    save_recent(self._recent)
+                self._rebuild_recent_menu()
+            return
+        self._open_path(path)
+
     def _read_document(self, path: Path) -> tuple[str, str | None]:
         """Load Markdown or MORGUL from *path*.
 
@@ -2158,6 +2214,7 @@ def _save(self) -> None:
         except OSError as exc:
             QMessageBox.warning(self, "Morgul", f"Could not save file:\n{exc}")
             return
+        self._add_recent(tab.path)
         tab.dirty = False
         self.tab_meta_changed()
 
@@ -2194,6 +2251,7 @@ def _save_as(self) -> None:
             QMessageBox.warning(self, "Morgul", f"Could not save file:\n{exc}")
             return
         tab.path = path
+        self._add_recent(path)
         tab.dirty = False
         self.tab_meta_changed()
 

src/morgul/session.py

@@ -13,6 +13,9 @@
 
 SESSION_VERSION = 1
 
+# Max entries remembered in the File → Open Recent list.
+RECENT_LIMIT = 10
+
 
 def session_root() -> Path:
     """Return ``~/.morgul``.
@@ -304,3 +307,48 @@ def clear_session() -> None:
     if root.is_dir():
         for path in root.glob("*.tab"):
             path.unlink(missing_ok=True)
+
+
+def recent_file() -> Path:
+    """Return ``~/.morgul/recent.json``.
+
+    Returns:
+        Path to the Open Recent list file.
+    """
+    return session_root() / "recent.json"
+
+
+def load_recent() -> list[str]:
+    """Read the recent-files list, newest first.
+
+    Returns:
+        Up to :data:`RECENT_LIMIT` file paths, or ``[]`` when missing/invalid.
+    """
+    path = recent_file()
+    if not path.is_file():
+        return []
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return []
+    if not isinstance(data, list):
+        return []
+    return [s for s in data if isinstance(s, str)][:RECENT_LIMIT]
+
+
+def save_recent(files: list[str]) -> None:
+    """Persist *files* (newest first) to ``~/.morgul/recent.json``."""
+    ensure_session_dirs()
+    path = recent_file()
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(
+        json.dumps(files[:RECENT_LIMIT], ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+        newline="\n",
+    )
+    tmp.replace(path)
+
+
+def clear_recent() -> None:
+    """Delete the recent-files list."""
+    recent_file().unlink(missing_ok=True)