feat(common): improve config

Author: egvimo

package.py

@@ -5,21 +5,26 @@
 import zipapp
 
 
-def archiver() -> None:
-    def archive_filter(path: Path):
-        return path in map(Path, [
-            'archiver.py',
-            'common.py'
-        ])
+def _create_archive(name: str, files: list[str]) -> None:
+    def file_filter(path: Path):
+        return path in map(Path, files)
 
     zipapp.create_archive(
-        source='scripts',
-        target='archiver.pyz',
-        interpreter='/usr/bin/env python3',
-        main='archiver:main',
-        filter=archive_filter
+        source="scripts",
+        target=f"{name}.pyz",
+        interpreter="/usr/bin/env python3",
+        main=f"{name}:main",
+        filter=file_filter,
     )
 
 
-if __name__ == '__main__':
-    globals()[sys.argv[1]]()
+def archiver() -> None:
+    _create_archive("archiver", ["archiver.py", "common.py"])
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        globals()[sys.argv[1]]()
+    else:
+        # TODO Make generic  # pylint: disable=fixme
+        archiver()

scripts/archiver.py

@@ -110,7 +110,7 @@ def _create_argument_parser() -> ArgumentParser:
 
     parent_parser = ArgumentParser(add_help=False)
     parent_parser.add_argument('-p', '--password', type=str, help='password')
-    parent_parser.add_argument('-v', '--verbose', type=str, help='verbose')
+    parent_parser.add_argument('-v', '--verbose', action='store_true', help='verbose')
 
     a_parser = subparsers.add_parser(
         'a', parents=[parent_parser], help='create archive')

scripts/common.py

@@ -1,33 +1,64 @@
 #!/usr/bin/env python3
 
 import json
+import logging
 import os
 from typing import Any
 
 
 class Config:  # pylint: disable=too-few-public-methods
-    _HOME = os.path.expanduser('~')
-    _XDG_CONFIG_HOME = os.environ.get('XDG_CONFIG_HOME') or \
-        os.path.join(_HOME, '.config')
-    _CONFIG_PATH = os.path.join(_XDG_CONFIG_HOME, 'scripts')
+    _HOME = os.path.expanduser("~")
+    _XDG_CONFIG_HOME = os.environ.get("XDG_CONFIG_HOME") or os.path.join(
+        _HOME, ".config"
+    )
+    _CONFIG_PATH = os.path.join(_XDG_CONFIG_HOME, "scripts")
 
     def __init__(self, config_file: str):
-        self._config_file = config_file
-        self._config = None
+        self._config: dict[str, Any] | None = None
+        if os.path.isfile(config_file):
+            self._config_file = config_file
+        elif os.path.isfile(os.path.join(self._CONFIG_PATH, config_file)):
+            self._config_file = os.path.join(self._CONFIG_PATH, config_file)
+        else:
+            self._config_file = None
 
-    def get_value(self, key: str) -> Any | None:
+    def get_config(self) -> dict[str, Any]:
         if self._config is None:
             self._config = self._read_config()
-        if key in self._config:
-            return self._config[key]
-        return None
+        return self._config
+
+    def set_config(self, config: dict[str, Any]) -> None:
+        self._config = config
+        with open(self._config_file, "w", encoding="utf-8") as file:
+            return json.dump(config, file)
+
+    def get_value(self, key: str) -> Any | None:
+        return self.get_config().get(key, None)
 
     def _read_config(self) -> dict[str, Any]:
-        if os.path.isfile(self._config_file):
-            config_path = self._config_file
-        elif os.path.isfile(os.path.join(self._CONFIG_PATH, self._config_file)):
-            config_path = os.path.join(self._CONFIG_PATH, self._config_file)
+        if self._config_file:
+            with open(self._config_file, "r", encoding="utf-8") as file:
+                return json.load(file)
         else:
             return {}
-        with open(config_path, 'r', encoding='utf-8') as config:
-            return json.load(config)
+
+
+class Logger:
+    def __init__(self) -> None:
+        logging.basicConfig(level=logging.INFO, format="%(message)s")
+        self._logger = logging.getLogger("scripts")
+
+    def verbose(self):
+        self._logger.setLevel(logging.DEBUG)
+
+    def debug(self, msg, *args, **kwargs) -> None:
+        self._logger.debug(msg, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs) -> None:
+        self._logger.info(msg, *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs) -> None:
+        self._logger.warning(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs) -> None:
+        self._logger.error(msg, *args, **kwargs)

tests/test_archiver.py

@@ -39,9 +39,7 @@ def test_archiving_with_config():
     with open(f"{TEST_PATH}/archiver.json", 'w', encoding='utf-8') as file:
         json.dump({'defaultPassword': 'test'}, file)
 
-    config = Config('archiver.json')
-    config._CONFIG_PATH = os.path.join(  # pylint: disable=protected-access
-        os.getcwd(), TEST_PATH)
+    config = Config(f"{TEST_PATH}/archiver.json")
 
     archiver = Archiver()
     archiver._config = config  # pylint: disable=protected-access

tests/test_common.py

@@ -7,27 +7,38 @@
 from scripts.common import Config
 
 
-TEST_PATH = './out'
-TARGET_DIR = f"{TEST_PATH}/test"
-TEST_ARCHIVE = f"{TEST_PATH}/test.7z"
-PASSWORD = 'test'
+TEST_PATH = "./out"
+TARGET_DIR = f"{TEST_PATH}/scripts"
+PASSWORD = "test"
 
 
 @pytest.fixture(autouse=True)
 def prepare():
     if os.path.exists(TEST_PATH):
         shutil.rmtree(TEST_PATH)
-    Path(TEST_PATH).mkdir(parents=True, exist_ok=True)
+    Path(TARGET_DIR).mkdir(parents=True, exist_ok=True)
 
 
 def test_config():
-    with open(f"{TEST_PATH}/test.json", 'w', encoding='utf-8') as config:
-        json.dump({'testKey': 'testValue'}, config)
+    with open(f"{TEST_PATH}/test.json", "w", encoding="utf-8") as file:
+        json.dump({"testKey": "testValue"}, file)
 
-    config = Config('test.json')
-    config._CONFIG_PATH = os.path.join(  # pylint: disable=protected-access
-        os.getcwd(), TEST_PATH)
+    config = Config(f"{TEST_PATH}/test.json")
 
-    value = config.get_value('testKey')
+    value = config.get_value("testKey")
 
-    assert value == 'testValue'
+    assert value == "testValue"
+
+
+@pytest.mark.skip(reason="Static variables are initialized on import")
+def test_config_with_config_home(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", TEST_PATH)
+
+    with open(f"{TARGET_DIR}/test.json", "w", encoding="utf-8") as file:
+        json.dump({"testKey": "testValue"}, file)
+
+    config = Config("test.json")
+
+    value = config.get_value("testKey")
+
+    assert value == "testValue"