Add settings persistence.

Author: porridge

README.md

@@ -33,24 +33,34 @@ Currently they are selected from the answers present in a 3x3 square visually su
 
 ## Optional Features
 
+Features can be turned on or off using command line options.
+For features listed in this section the setting is saved by the program.
+This means the setting applies also on future program executions, unless explicitly changed.
+
 ### Showing Feedback
 
 By default the application provides feedback on **incorrect** answers.
 The application will briefly pause, highlighting the correct and incorrect answers using green and red background.
-Pass the `--no-show-feedback` option to disable providing feedback.
+- Pass the `--no-show-feedback` option to disable providing feedback.
+- Pass the `--show-feedback` option to enable providing feedback.
 
 ### Showing Scores
 
 By default the application displays the total number of correct and incorrect answers.
 They are displayed in the lower corners of the main window.
-Pass the `--no-show-scores` option to hide scores.
-
-Use the`--score-font` option to select the font to use for displaying scores.
+- Pass the `--no-show-scores` option to hide scores.
+- Pass the `--show-scores` option to show scores.
+- Use the`--score-font` option to select the font to use for displaying scores.
 
 ### Limiting the Number of Questions
 
 By default the application will keep asking questions until it is closed.
-Pass the `--limit N` option to exit once `N` questions have been answered correctly.
+- Pass the `--limit N` option to exit once `N` questions have been answered correctly.
+- Pass `--limit 0` to bring back the default behaviour of never-ending questions.
+
+## Special options
+
+Options listed in this section only apply to the current execution of the program.
 
 ### Showing Saved State
 

settings_test.py

@@ -0,0 +1,147 @@
+#!/usr/bin/python3
+
+# tabliczka: a program for learning multiplication table
+# Copyright 2022 Marcin Owsiany <marcin@owsiany.pl>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>
+
+import unittest
+import tabliczka
+
+
+class FakeSettingsFS:
+
+    def read(self):
+        pass
+
+    def write(self, settings):
+        pass
+
+
+class NoSettingsFS(FakeSettingsFS):
+    pass
+
+
+class SomeSettingsFS(FakeSettingsFS):
+
+    def __init__(self, settings):
+        self._settings = settings
+
+    def read(self):
+        return self._settings
+
+    def write(self, settings):
+        self._settings.clear()
+        self._settings.update(settings)
+
+
+class TestSettings(unittest.TestCase):
+
+    def test_no_settings(self):
+        fs = NoSettingsFS()
+        args = tabliczka.get_argument_parser().parse_args([])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, None)
+        self.assertEqual(s.show_feedback, True)
+        self.assertEqual(s.show_scores, True)
+        self.assertEqual(s.score_font, 'monospace')
+
+    def test_settings_from_fs(self):
+        fs = SomeSettingsFS(dict(
+            limit=1,
+            show_feedback=False,
+            show_scores=False,
+            score_font='dingbats'))
+        args = tabliczka.get_argument_parser().parse_args([])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, 1)
+        self.assertEqual(s.show_feedback, False)
+        self.assertEqual(s.show_scores, False)
+        self.assertEqual(s.score_font, 'dingbats')
+
+    def test_settings_from_fs_overridden(self):
+        fs = SomeSettingsFS(dict(
+            limit=1,
+            show_feedback=False,
+            show_scores=False,
+            score_font='dingbats'))
+        args = tabliczka.get_argument_parser().parse_args([
+                '--limit', '2',
+                '--show-feedback',
+                '--show-scores',
+                '--score-font=asdf'
+            ])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, 2)
+        self.assertEqual(s.show_feedback, True)
+        self.assertEqual(s.show_scores, True)
+        self.assertEqual(s.score_font, 'asdf')
+
+    def test_settings_lifecycle(self):
+        settings_backend = dict()
+        fs = SomeSettingsFS(settings_backend)
+        args = tabliczka.get_argument_parser().parse_args([
+                '--limit', '2',
+                '--no-show-feedback',
+                '--no-show-scores',
+                '--score-font=asdf'
+            ])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, 2)
+        self.assertEqual(s.show_feedback, False)
+        self.assertEqual(s.show_scores, False)
+        self.assertEqual(s.score_font, 'asdf')
+        self.assertDictEqual(settings_backend, dict(
+            limit=2,
+            show_feedback=False,
+            show_scores=False,
+            score_font='asdf'))
+
+        args2 = tabliczka.get_argument_parser().parse_args([])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, 2)
+        self.assertEqual(s.show_feedback, False)
+        self.assertEqual(s.show_scores, False)
+        self.assertEqual(s.score_font, 'asdf')
+        self.assertDictEqual(settings_backend, dict(
+            limit=2,
+            show_feedback=False,
+            show_scores=False,
+            score_font='asdf'))
+
+    def test_settings_lifecycle_partial(self):
+        settings_backend = dict()
+        fs = SomeSettingsFS(settings_backend)
+        args = tabliczka.get_argument_parser().parse_args([
+                '--no-show-feedback'
+            ])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, None)
+        self.assertEqual(s.show_feedback, False)
+        self.assertEqual(s.show_scores, True)
+        self.assertEqual(s.score_font, 'monospace')
+        self.assertDictEqual(settings_backend, dict(show_feedback=False))
+
+        args2 = tabliczka.get_argument_parser().parse_args([])
+        s = tabliczka.Settings(fs, args)
+        self.assertEqual(s.limit, None)
+        self.assertEqual(s.show_feedback, False)
+        self.assertEqual(s.show_scores, True)
+        self.assertEqual(s.score_font, 'monospace')
+        self.assertDictEqual(settings_backend, dict(show_feedback=False))
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tabliczka.py

@@ -19,6 +19,7 @@
 
 import argparse
 import itertools
+import json
 import logging
 import pickle
 import os
@@ -46,6 +47,7 @@
 _xdg_state_home = os.environ.get('XDG_STATE_HOME') or os.path.join(_home, '.local', 'state')
 _state_home = os.path.join(_xdg_state_home, 'tabliczka')
 _state_file = os.path.join(_state_home, 'state.pickle')
+_settings_filename = os.path.join(_state_home, 'settings.json')
 
 
 class QuitException(Exception):
@@ -60,7 +62,7 @@ def get_argument_parser():
     parser.add_argument('--dump', action='store_true', help='Just show the saved state and quit.')
     parser.add_argument('--debug', action='store_true', help='Turn on debug-level logging.')
     parser.add_argument('--repl', action='store_true', help='Start the REPL before main program.')
-    # Options that control behaviour.
+    # Options that control behaviour. These are persisted in the settings file.
     parser.add_argument('--limit', type=int, help='Quit after correctly solving this many questions (0 means no limit).')
     parser.add_argument('--show-feedback', action=argparse.BooleanOptionalAction, help='Show feedback on wrong answers.')
     parser.add_argument('--show-scores', action=argparse.BooleanOptionalAction, help='Show scores in main window.')
@@ -69,6 +71,20 @@ def get_argument_parser():
     return parser
 
 
+class FS:
+    def read(self):
+        try:
+            with open(_settings_filename, "r") as settings_file:
+                return json.load(settings_file)
+        except FileNotFoundError:
+            pass
+
+    def write(self, settings):
+        os.makedirs(_state_home, mode=0o700, exist_ok=True)
+        with open(_settings_filename, "w") as settings_file:
+            json.dump(settings, settings_file)
+
+
 def main():
 
     parser = get_argument_parser()
@@ -87,7 +103,8 @@ def main():
         import code
         code.interact()
 
-    settings = Settings(args)
+    fs = FS()
+    settings = Settings(fs, args)
 
     with get_ui_class(args.ui)(settings) as ui:
         try:
@@ -101,24 +118,46 @@ def get_ui_class(ui_name):
 
 
 class Settings:
-    def __init__(self, args):
-        self._args = args
+
+    def __init__(self, fs, parsed_args):
+        self._s = dict((k, None) for k in [
+            'limit', 'show_scores', 'show_feedback', 'score_font'])
+        self._load_settings(fs)
+        self._merge_settings(parsed_args)
+        self._save_settings(fs)
 
     @property
     def limit(self):
-        return self._args.limit
+        return self._s['limit']
 
     @property
     def show_scores(self):
-        return _truthify(self._args.show_scores)
+        return _truthify(self._s['show_scores'])
 
     @property
     def show_feedback(self):
-        return _truthify(self._args.show_scores)
+        return _truthify(self._s['show_feedback'])
 
     @property
     def score_font(self):
-        return self._args.score_font or _DEFAULT_SCORE_FONT
+        return self._s['score_font'] or _DEFAULT_SCORE_FONT
+
+    def _load_settings(self, fs):
+        loaded = fs.read()
+        if not loaded:
+            return
+        for s in self._s.keys():
+            if s in loaded and loaded[s] is not None:
+                self._s[s] = loaded[s]
+
+    def _merge_settings(self, overrides):
+        for s in self._s.keys():
+            override = getattr(overrides, s, None)
+            if override is not None:
+                self._s[s] = override
+
+    def _save_settings(self, fs):
+        fs.write(dict(kv for kv in self._s.items() if kv[1] is not None))
 
 
 def _truthify(setting):