feat: settings menu in tui

2 files changed, 269 insertions, 11 deletions

diff --git a/tests/test_hub.py b/tests/test_hub.py
index 21f795e..b3a17e8 100644
--- a/tests/test_hub.py
+++ b/tests/test_hub.py
@@ -71,14 +71,14 @@ class HubMenuTests(unittest.TestCase):
         return BackendStatus(key, label, installed=False, configured=False)
 
     def test_quit_returns_none_when_no_backend(self):
-        # No backends installed/running: menu is [Set up, Quit]. Quit is the
-        # 2nd option (Down once) then Enter.
-        screen = FakeScreen(keys=[FakeCurses.KEY_DOWN, 10])
+        # No backends installed/running: menu is [Set up, Settings, Quit].
+        # Quit is the 3rd option (Down twice) then Enter.
+        screen = FakeScreen(keys=[FakeCurses.KEY_DOWN, FakeCurses.KEY_DOWN, 10])
         with patch.object(hub, "detect_all", return_value=[]):
             result = hub._hub_menu(screen)
         self.assertIsNone(result)
 
-    def test_menu_has_only_setup_and_quit_without_backends(self):
+    def test_menu_has_only_setup_settings_and_quit_without_backends(self):
         # Capture the options handed to tui.menu: with nothing installed or
         # running, Convert/Configure must be absent.
         captured = {}
@@ -92,9 +92,10 @@ class HubMenuTests(unittest.TestCase):
                 patch.object(hub, "detect_all", return_value=[]):
             hub._hub_menu(screen)
         labels = [label for label, _ in captured["options"]]
-        self.assertEqual(labels, ["Set up a backend...", "Quit"])
+        self.assertEqual(labels, ["Set up a backend...", "Settings...",
+                                  "Quit"])
 
-    def test_menu_has_all_five_when_one_installed(self):
+    def test_menu_has_all_six_when_one_installed(self):
         captured = {}
 
         def fake_menu(stdscr, title, options, **kwargs):
@@ -112,7 +113,7 @@ class HubMenuTests(unittest.TestCase):
         self.assertEqual(
             labels,
             ["Convert books...", "Set up a backend...",
-             "Configure a backend...", "Server...", "Quit"])
+             "Configure a backend...", "Server...", "Settings...", "Quit"])
         # The status table is passed through, one row per backend.
         self.assertEqual(captured["rows"],
                          [("qwen-tts", "installed", "warn", "body")])
@@ -138,7 +139,7 @@ class HubMenuTests(unittest.TestCase):
             [("audio.cpp", "unavailable", "err", "dim"),
              ("qwen-tts", "running", "ok", "body")])
 
-    def test_menu_has_all_five_when_one_running_only(self):
+    def test_menu_has_all_six_when_one_running_only(self):
         # Running but not installed (an external server) still unlocks the
         # Convert/Configure/Server entries.
         captured = {}
@@ -157,7 +158,7 @@ class HubMenuTests(unittest.TestCase):
         self.assertEqual(
             labels,
             ["Convert books...", "Set up a backend...",
-             "Configure a backend...", "Server...", "Quit"])
+             "Configure a backend...", "Server...", "Settings...", "Quit"])
 
     def test_convert_with_no_available_backend_offers_setup(self):
         # One installed-but-not-ready backend → Convert is offered. The
@@ -182,11 +183,12 @@ class HubMenuTests(unittest.TestCase):
         with patch.object(hub, "detect_all", return_value=statuses), \
                 patch.object(hub, "REGISTRY", infos):
             # Convert(Enter), setup-entry(Enter), Esc on setup menu,
-            # back at main menu -> Down x4 -> Enter (Quit).
+            # back at main menu -> Down x5 -> Enter (Quit; Settings sits
+            # just before it).
             screen = FakeScreen(keys=[10, 10, 27,
                                        FakeCurses.KEY_DOWN, FakeCurses.KEY_DOWN,
                                        FakeCurses.KEY_DOWN, FakeCurses.KEY_DOWN,
-                                        10])
+                                       FakeCurses.KEY_DOWN, 10])
             result = hub._hub_menu(screen)
         self.assertIsNone(result)
 
@@ -316,5 +318,185 @@ class AddAutostartTests(unittest.TestCase):
         self.assertNotIn("autostart", cmd[2])
 
 
+class SettingsTests(unittest.TestCase):
+    """Settings menu: field collection, validation, config.py writing."""
+
+    def test_write_config_preserves_comments_and_other_lines(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "config.py"
+            path.write_text(
+                "# Default output options\n"
+                'AUDIO_FORMAT = "m4b"\n'
+                'AUDIO_BITRATE = "128k"\n'
+                'LANGUAGE = "English"\n'
+                "\n"
+                "CHUNK_SIZE = 250  # words per request\n",
+                encoding="utf-8")
+            with patch.object(hub.config, "__file__", str(path)):
+                hub._write_config({"AUDIO_FORMAT": "mp3",
+                                   "AUDIO_BITRATE": "192k",
+                                   "LANGUAGE": "Japanese",
+                                   "CHUNK_SIZE": 300})
+            text = path.read_text(encoding="utf-8")
+        self.assertEqual(
+            text,
+            "# Default output options\n"
+            'AUDIO_FORMAT = "mp3"\n'
+            'AUDIO_BITRATE = "192k"\n'
+            'LANGUAGE = "Japanese"\n'
+            "\n"
+            "CHUNK_SIZE = 300  # words per request\n")
+
+    def test_write_config_missing_key_raises(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "config.py"
+            path.write_text("X = 1\n", encoding="utf-8")
+            with patch.object(hub.config, "__file__", str(path)):
+                with self.assertRaises(ValueError):
+                    hub._write_config({"AUDIO_FORMAT": "mp3"})
+
+    def test_apply_settings_writes_and_reloads_in_memory(self):
+        written = {}
+
+        def fake_write(updates):
+            written.update(updates)
+
+        original = {name: getattr(hub.config, name) for name in
+                    ("AUDIO_FORMAT", "AUDIO_BITRATE", "LANGUAGE",
+                     "CHUNK_SIZE")}
+        self.addCleanup(lambda: [setattr(hub.config, name, value)
+                                 for name, value in original.items()])
+        values = {"audio_format": "ogg", "audio_bitrate": " 192k ",
+                  "language": "en", "chunk_size": "300"}
+        with patch.object(hub, "_write_config", fake_write):
+            hub._apply_settings(values)
+        # Values are trimmed and language normalized to a display name.
+        self.assertEqual(written, {"AUDIO_FORMAT": "ogg",
+                                   "AUDIO_BITRATE": "192k",
+                                   "LANGUAGE": "English",
+                                   "CHUNK_SIZE": 300})
+        # In-memory config is reloaded so this session sees the change.
+        self.assertEqual(hub.config.AUDIO_FORMAT, "ogg")
+        self.assertEqual(hub.config.AUDIO_BITRATE, "192k")
+        self.assertEqual(hub.config.LANGUAGE, "English")
+        self.assertEqual(hub.config.CHUNK_SIZE, 300)
+
+    def test_apply_settings_rejects_bad_values(self):
+        original = {name: getattr(hub.config, name) for name in
+                    ("AUDIO_FORMAT", "AUDIO_BITRATE", "LANGUAGE",
+                     "CHUNK_SIZE")}
+        self.addCleanup(lambda: [setattr(hub.config, name, value)
+                                 for name, value in original.items()])
+        with patch.object(hub, "_write_config") as mk_write:
+            with self.assertRaises(ValueError):
+                hub._apply_settings({"audio_format": "m4b",
+                                     "audio_bitrate": "128k",
+                                     "language": "Klingon",
+                                     "chunk_size": "250"})
+            with self.assertRaises(ValueError):
+                hub._apply_settings({"audio_format": "m4b",
+                                     "audio_bitrate": "128k",
+                                     "language": "English",
+                                     "chunk_size": "0"})
+            mk_write.assert_not_called()
+
+    def test_field_validators(self):
+        self.assertIsNone(hub._validate_bitrate("128k"))
+        self.assertIsNotNone(hub._validate_bitrate("   "))
+        self.assertIsNone(hub._validate_language("English"))
+        self.assertIsNone(hub._validate_language("en"))
+        self.assertIsNotNone(hub._validate_language("Klingon"))
+        self.assertIsNone(hub._validate_chunk_size("250"))
+        self.assertIsNotNone(hub._validate_chunk_size("abc"))
+        self.assertIsNotNone(hub._validate_chunk_size("0"))
+
+    def test_settings_menu_builds_form_and_saves(self):
+        captured = {}
+
+        def fake_form(stdscr, title, fields, back_value=None):
+            captured["fields"] = fields
+            return {"audio_format": "ogg", "audio_bitrate": "192k",
+                    "language": "English", "chunk_size": "300"}
+
+        applied = []
+
+        def fake_apply(values):
+            applied.append(values)
+
+        def fake_flash(stdscr, text, kind="warn"):
+            captured["flash"] = (text, kind)
+
+        with patch.object(hub.tui, "form", fake_form), \
+                patch.object(hub, "_apply_settings", fake_apply), \
+                patch.object(hub.tui, "flash", fake_flash):
+            hub._settings_menu(None)
+        self.assertEqual([f["key"] for f in captured["fields"]],
+                         ["audio_format", "audio_bitrate", "language",
+                          "chunk_size"])
+        kinds = {f["key"]: f["kind"] for f in captured["fields"]}
+        self.assertEqual(kinds["audio_format"], "choice")
+        self.assertEqual(kinds["audio_bitrate"], "text")
+        self.assertEqual(applied, [{"audio_format": "ogg",
+                                    "audio_bitrate": "192k",
+                                    "language": "English",
+                                    "chunk_size": "300"}])
+        self.assertEqual(captured["flash"], ("Settings saved.", "ok"))
+
+    def test_settings_menu_cancel_does_not_apply(self):
+        def fake_form(stdscr, title, fields, back_value=None):
+            return back_value  # user pressed Cancel
+
+        applied = []
+
+        def fake_apply(values):
+            applied.append(values)
+
+        with patch.object(hub.tui, "form", fake_form), \
+                patch.object(hub, "_apply_settings", fake_apply):
+            hub._settings_menu(None)
+        self.assertEqual(applied, [])
+
+    def test_settings_menu_writes_config_end_to_end(self):
+        import tempfile
+        tui._THEME.clear()
+        self.addCleanup(tui._THEME.clear)
+        curses = FakeCurses()
+        patcher = patch.dict("sys.modules", {"curses": curses})
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+        original = {name: getattr(hub.config, name) for name in
+                    ("AUDIO_FORMAT", "AUDIO_BITRATE", "LANGUAGE",
+                     "CHUNK_SIZE")}
+        self.addCleanup(lambda: [setattr(hub.config, name, value)
+                                 for name, value in original.items()])
+
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "config.py"
+            path.write_text(
+                "# Default output options\n"
+                'AUDIO_FORMAT = "m4b"\n'
+                'AUDIO_BITRATE = "128k"\n'
+                'LANGUAGE = "English"\n'
+                "\n"
+                "CHUNK_SIZE = 250\n",
+                encoding="utf-8")
+            with patch.object(hub.config, "__file__", str(path)):
+                # Down to Chunk size, Enter -> editor, Ctrl-U + '300',
+                # Enter; Tab -> Save, Enter; a key dismisses the flash.
+                screen = FakeScreen(keys=[
+                    FakeCurses.KEY_DOWN, FakeCurses.KEY_DOWN,
+                    FakeCurses.KEY_DOWN, 10, 21, ord("3"), ord("0"),
+                    ord("0"), 10, 9, 10, 10])
+                hub._settings_menu(screen)
+            text = path.read_text(encoding="utf-8")
+        self.assertIn('AUDIO_FORMAT = "m4b"', text)
+        self.assertIn("CHUNK_SIZE = 300", text)
+        # The running session also picked up the change in-memory.
+        self.assertEqual(hub.config.CHUNK_SIZE, 300)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_tui.py b/tests/test_tui.py
index 58d8273..c121d55 100644
--- a/tests/test_tui.py
+++ b/tests/test_tui.py
@@ -365,6 +365,82 @@ class LineEditTests(TuiTestCase):
         self.assertEqual(value, "teq")
 
 
+class FormTests(TuiTestCase):
+    def _fields(self):
+        # Fresh dicts each call: form() edits field values in place, and a
+        # shared class attribute would leak edits between tests.
+        return [
+            {"key": "fmt", "label": "Format", "kind": "choice",
+             "value": "m4b", "choices": ["mp3", "m4b", "ogg"]},
+            {"key": "chunk", "label": "Chunk", "kind": "text",
+             "value": "250"},
+        ]
+
+    def test_save_returns_current_values(self):
+        screen = FakeScreen(keys=[9, 10])  # Tab -> Save, Enter
+        result = tui.form(screen, "Settings", self._fields())
+        self.assertEqual(result, {"fmt": "m4b", "chunk": "250"})
+
+    def test_cancel_returns_back_value(self):
+        marker = object()
+        # Tab -> buttons, Left -> Cancel, Enter.
+        screen = FakeScreen(keys=[9, FakeCurses.KEY_LEFT, 10])
+        result = tui.form(screen, "Settings", self._fields(),
+                          back_value=marker)
+        self.assertIs(result, marker)
+
+    def test_esc_returns_back_value(self):
+        marker = object()
+        screen = FakeScreen(keys=[27])
+        self.assertIs(
+            tui.form(screen, "Settings", self._fields(), back_value=marker),
+            marker)
+
+    def test_q_still_aborts_with_back_value(self):
+        marker = object()
+        screen = FakeScreen(keys=[ord("q")])
+        with self.assertRaises(tui.WizardCancelled):
+            tui.form(screen, "Settings", self._fields(), back_value=marker)
+
+    def test_choice_field_picks_another_value(self):
+        # Enter opens the choice menu on 'm4b' (index 1); Down moves to
+        # 'ogg', Enter accepts; Tab -> Save, Enter.
+        screen = FakeScreen(keys=[10, FakeCurses.KEY_DOWN, 10, 9, 10])
+        result = tui.form(screen, "Settings", self._fields())
+        self.assertEqual(result, {"fmt": "ogg", "chunk": "250"})
+
+    def test_text_field_edits_then_saves(self):
+        # Down to the text row, Enter opens the editor, type 'x', Enter,
+        # then Tab -> Save, Enter.
+        screen = FakeScreen(
+            keys=[FakeCurses.KEY_DOWN, 10, ord("x"), 10, 9, 10])
+        result = tui.form(screen, "Settings", self._fields())
+        self.assertEqual(result, {"fmt": "m4b", "chunk": "250x"})
+
+    def test_validation_error_refuses_save_then_recovers(self):
+        fields = [
+            {"key": "chunk", "label": "Chunk", "kind": "text", "value": "bad",
+             "validate": lambda s: None if s.isdigit() else "digits only"},
+            {"key": "fmt", "label": "Format", "kind": "text", "value": "x"},
+        ]
+        # Tab->Save(Enter) fails, the flash consumes the next key; Enter
+        # reopens the editor, Ctrl-U clears 'bad', type '120', Enter; then
+        # Tab->Save(Enter).
+        keys = [9, 10, 10, 10, 21, ord("1"), ord("2"), ord("0"), 10, 9, 10]
+        screen = FakeScreen(keys=keys)
+        result = tui.form(screen, "Settings", fields)
+        self.assertEqual(result, {"chunk": "120", "fmt": "x"})
+
+    def test_rows_left_justified_inside_the_border(self):
+        screen = FakeScreen(keys=[9, 10])
+        tui.form(screen, "Settings", self._fields())
+        self.assert_inside_border(screen)
+
+    def test_empty_fields_rejected(self):
+        with self.assertRaises(ValueError):
+            tui.form(self.screen, "Settings", [])
+
+
 def _accept_audio_cpp(entry: Path):
     """auto_select callback that accepts an 'audio.cpp' checkout root."""
     if entry.name == "audio.cpp" and (entry / "model_specs").is_dir():