Add config write functionality to Config class

Author: erikwa

fusesoc/config.py

@@ -13,8 +13,10 @@
 
 
 class Config:
+    default_section = "main"
+
     def __init__(self, path=None):
-        config = CP()
+        self._cp = CP(default_section=Config.default_section)
 
         if path is None:
             xdg_config_home = os.environ.get("XDG_CONFIG_HOME") or os.path.join(
@@ -33,39 +35,34 @@ def __init__(self, path=None):
             config_files = [path]
 
         logger.debug("Looking for config files from " + ":".join(config_files))
-        files_read = config.read(config_files)
+        files_read = self._cp.read(config_files)
         logger.debug("Found config files in " + ":".join(files_read))
         self._path = files_read[-1] if files_read else None
 
-        self.build_root = self._get_build_root(config)
-        self.cache_root = self._get_cache_root(config)
-        self.library_root = self._get_library_root(config)
-        self.ignored_dirs = self._get_ignored_dirs(config)
-
         os.makedirs(self.cache_root, exist_ok=True)
 
         # Parse library sections
         libraries = []
-        library_sections = [x for x in config.sections() if x.startswith("library")]
+        library_sections = [x for x in self._cp.sections() if x.startswith("library")]
         for section in library_sections:
             name = section.partition(".")[2]
             try:
-                location = config.get(section, "location")
+                location = self._cp.get(section, "location")
             except configparser.NoOptionError:
                 location = os.path.join(self.library_root, name)
 
             try:
-                auto_sync = config.getboolean(section, "auto-sync")
+                auto_sync = self._cp.getboolean(section, "auto-sync")
             except configparser.NoOptionError:
                 auto_sync = True
             except ValueError as e:
                 _s = "Error parsing auto-sync '{}'. Ignoring library '{}'"
                 logger.warning(_s.format(str(e), name))
                 continue
 
-            sync_uri = config.get(section, "sync-uri", fallback=None)
-            sync_version = config.get(section, "sync-version", fallback=None)
-            sync_type = config.get(section, "sync-type", fallback=None)
+            sync_uri = self._cp.get(section, "sync-uri", fallback=None)
+            sync_version = self._cp.get(section, "sync-version", fallback=None)
+            sync_type = self._cp.get(section, "sync-type", fallback=None)
 
             libraries.append(
                 Library(name, location, sync_type, sync_uri, sync_version, auto_sync)
@@ -81,8 +78,14 @@ def __init__(self, path=None):
         logger.debug("cache_root=" + self.cache_root)
         logger.debug("library_root=" + self.library_root)
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.write()
+
     def _resolve_path_from_cfg(self, path):
-        # We only call resolve_path_from_cfg if config.get(...) returned
+        # We only call resolve_path_from_cfg if self._cp.get(...) returned
         # something. That, in turn, only happens if we actually managed to read
         # a config file, meaning that files_read will have been nonempty in the
         # constructor and self._path will not be None.
@@ -95,23 +98,23 @@ def _resolve_path_from_cfg(self, path):
             cfg_file_dir = os.path.dirname(self._path)
             return os.path.join(cfg_file_dir, expanded)
 
-    def _path_from_cfg(self, config, name):
-        as_str = config.get("main", name, fallback=None)
+    def _path_from_cfg(self, name):
+        as_str = self._cp.get(Config.default_section, name, fallback=None)
         return self._resolve_path_from_cfg(as_str) if as_str is not None else None
 
-    def _paths_from_cfg(self, config, name):
-        paths = config.get("main", name, fallback="")
+    def _paths_from_cfg(self, name):
+        paths = self._cp.get(Config.default_section, name, fallback="")
         return [self._resolve_path_from_cfg(p) for p in paths.split()]
 
-    def _get_build_root(self, config):
-        from_cfg = self._path_from_cfg(config, "build_root")
+    def _get_build_root(self):
+        from_cfg = self._path_from_cfg("build_root")
         if from_cfg is not None:
             return from_cfg
 
         return os.path.abspath("build")
 
-    def _get_cache_root(self, config):
-        from_cfg = self._path_from_cfg(config, "cache_root")
+    def _get_cache_root(self):
+        from_cfg = self._path_from_cfg("cache_root")
         if from_cfg is not None:
             return from_cfg
 
@@ -120,8 +123,8 @@ def _get_cache_root(self, config):
         )
         return os.path.join(xdg_cache_home, "fusesoc")
 
-    def _get_library_root(self, config):
-        from_cfg = self._path_from_cfg(config, "library_root")
+    def _get_library_root(self):
+        from_cfg = self._path_from_cfg("library_root")
         if from_cfg is not None:
             return from_cfg
 
@@ -130,40 +133,79 @@ def _get_library_root(self, config):
         )
         return os.path.join(xdg_data_home, "fusesoc")
 
-    def _get_ignored_dirs(self, config):
-        return self._paths_from_cfg(config, "ignored_dirs")
+    def _get_ignored_dirs(self):
+        return self._paths_from_cfg("ignored_dirs")
+
+    def _set_default_section(self, name, val):
+        self._cp.set(Config.default_section, name, str(val))
+
+    @property
+    def build_root(self):
+        return self._get_build_root()
+
+    @build_root.setter
+    def build_root(self, val):
+        self._set_default_section("build_root", val)
+
+    @property
+    def cache_root(self):
+        return self._get_cache_root()
+
+    @cache_root.setter
+    def cache_root(self, val):
+        self._set_default_section("cache_root", val)
+
+    @property
+    def library_root(self):
+        return self._get_library_root()
+
+    @library_root.setter
+    def library_root(self, val):
+        self._set_default_section("library_root", val)
+
+    @property
+    def ignored_dirs(self):
+        return self._get_ignored_dirs()
+
+    @ignored_dirs.setter
+    def ignored_dirs(self, val):
+        self._set_default_section(
+            "ignored_dirs", " ".join(val) if type(val) == list else val
+        )
+
+    def write(self):
+        if not hasattr(self, "_path"):
+            raise RuntimeError("No FuseSoC config file found - can't write config")
+
+        with open(self._path, "w") as conf_file:
+            self._cp.write(conf_file)
 
     def add_library(self, library):
         from fusesoc.provider import get_provider
 
-        if not hasattr(self, "_path"):
-            raise RuntimeError("No FuseSoC config file found - can't add library")
         section_name = "library." + library.name
 
-        config = CP()
-        config.read(self._path)
-
-        if section_name in config.sections():
+        if section_name in self._cp.sections():
             logger.warning(
                 "Not adding library. {} already exists in configuration file".format(
                     library.name
                 )
             )
             return
 
-        config.add_section(section_name)
+        self._cp.add_section(section_name)
 
-        config.set(section_name, "location", library.location)
+        self._cp.set(section_name, "location", library.location)
 
         if library.sync_type:
-            config.set(section_name, "sync-uri", library.sync_uri)
+            self._cp.set(section_name, "sync-uri", library.sync_uri)
 
             if library.sync_version is not None:
-                config.set(section_name, "sync-version", library.sync_version)
+                self._cp.set(section_name, "sync-version", library.sync_version)
 
-            config.set(section_name, "sync-type", library.sync_type)
+            self._cp.set(section_name, "sync-type", library.sync_type)
             _auto_sync = "true" if library.auto_sync else "false"
-            config.set(section_name, "auto-sync", _auto_sync)
+            self._cp.set(section_name, "auto-sync", _auto_sync)
 
         try:
             provider = get_provider(library.sync_type)
@@ -172,5 +214,4 @@ def add_library(self, library):
 
         provider.init_library(library)
 
-        with open(self._path, "w") as conf_file:
-            config.write(conf_file)
+        self.write()