4th reorganisation step: Fix parser and make sure tests run

Author: abravalheri

src/configupdater/__init__.py

@@ -17,3 +17,4 @@
 
 # import everything and rely on __ALL__
 from .configupdater import *  # noqa
+from .parser import *  # noqa

src/configupdater/block.py

@@ -33,6 +33,9 @@ def __init__(self, container: "Container[T]"):
     def __str__(self) -> str:
         return "".join(self._lines)
 
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: {str(self)!r}>"
+
     def __eq__(self, other) -> bool:
         if isinstance(other, self.__class__):
             return str(self) == str(other)
@@ -113,15 +116,9 @@ class Comment(Block[T]):
     def __init__(self, container: "Container[T]"):
         super().__init__(container=container)
 
-    def __repr__(self) -> str:
-        return "<Comment>"
-
 
 class Space(Block[T]):
     """Vertical space block of new lines"""
 
     def __init__(self, container: "Container[T]"):
         super().__init__(container=container)
-
-    def __repr__(self) -> str:
-        return "<Space>"

src/configupdater/builder.py

@@ -56,7 +56,8 @@ def section(self: T, section) -> T:
             # create a new section
             section = Section(section, container=container)
         elif not isinstance(section, Section):
-            raise ValueError("Parameter must be a string or Section type!")
+            msg = "Parameter must be a string or Section type!"
+            raise ValueError(msg, {"container": section})
 
         if container.has_section(section.name):
             raise DuplicateSectionError(section.name)
@@ -98,7 +99,8 @@ def option(self: T, key, value=None, **kwargs) -> T:
         from .section import Section
 
         if not isinstance(self._container, Section):
-            raise ValueError("Options can only be added inside a section!")
+            msg = "Options can only be added inside a section!"
+            raise ValueError(msg, {"container": self._container})
         option = Option(key, value, container=self._container, **kwargs)
         if option.key in self._container.options():
             raise DuplicateOptionError(self._container.name, option.key)

src/configupdater/configupdater.py

@@ -1,16 +1,32 @@
-import io
-import os
 import sys
 from configparser import Error
-from typing import Optional, TextIO, Tuple, Union, cast
+from typing import Optional, TextIO, Tuple, TypeVar
 
 if sys.version_info[:2] >= (3, 9):
-    from collections.abc import Iterable, MutableMapping
+    from collections.abc import Iterable
 
     List = list
     Dict = dict
 else:
-    from typing import Iterable, MutableMapping
+    from typing import Iterable
+
+from .block import Comment, Space
+from .document import Document
+from .option import Option
+from .parser import Parser
+from .section import Section
+
+__all__ = [
+    "ConfigUpdater",
+    "Section",
+    "Option",
+    "Comment",
+    "Space",
+    "Parser",
+    "NoConfigFileReadError",
+]
+
+T = TypeVar("T", bound="ConfigUpdater")
 
 
 class NoConfigFileReadError(Error):
@@ -20,11 +36,8 @@ def __init__(self):
         super().__init__("No configuration file was yet read! Use .read(...) first.")
 
 
-ConfigContent = Union["Section", "Comment", "Space"]
-
-
-class ConfigUpdater(Container[ConfigContent], MutableMapping[str, Section]):
-    """Parser for updating configuration files.
+class ConfigUpdater(Document):
+    """Tool to parse and modify existing ``cfg`` files.
 
     ConfigUpdater follows the API of ConfigParser with some differences:
       * inline comments are treated as part of a key's value,
@@ -52,20 +65,34 @@ def __init__(
         empty_lines_in_values: bool = True,
         space_around_delimiters: bool = True,
     ):
-        pass
-
-    def read(self, filename: str, encoding: Optional[str] = None):
+        self._parser_opts = {
+            "allow_no_value": allow_no_value,
+            "delimiters": delimiters,
+            "comment_prefixes": comment_prefixes,
+            "inline_comment_prefixes": inline_comment_prefixes,
+            "strict": strict,
+            "empty_lines_in_values": empty_lines_in_values,
+            "space_around_delimiters": space_around_delimiters,
+        }
+        self._filename: Optional[str] = None
+        super().__init__()
+
+    def _parser(self, **kwargs):
+        opts = {"optionxform": self.optionxform, **self._parser_opts, **kwargs}
+        return Parser(**opts)
+
+    def read(self: T, filename: str, encoding: Optional[str] = None) -> T:
         """Read and parse a filename.
 
         Args:
             filename (str): path to file
             encoding (str): encoding of file, default None
         """
-        with open(filename, encoding=encoding) as fp:
-            self._read(fp, filename)
-        self._filename = os.path.abspath(filename)
+        self.remove_all()
+        self._filename = filename
+        return self._parser().read(filename, encoding, self)
 
-    def read_file(self, f: Iterable[str], source: Optional[str] = None):
+    def read_file(self: T, f: Iterable[str], source: Optional[str] = None) -> T:
         """Like read() but the argument must be a file-like object.
 
         The ``f`` argument must be iterable, returning one line at a time.
@@ -77,24 +104,20 @@ def read_file(self, f: Iterable[str], source: Optional[str] = None):
             f: file like object
             source (str): reference name for file object, default None
         """
-        if isinstance(f, str):
-            raise RuntimeError("f must be a file-like object, not string!")
-        if source is None:
-            try:
-                source = cast(str, cast(io.FileIO, f).name)
-            except AttributeError:
-                source = "<???>"
-        self._read(f, source)
-
-    def read_string(self, string: str, source="<string>"):
+        self.remove_all()
+        if hasattr(f, "name"):
+            self._filename = f.name  # type: ignore[attr-defined]
+        return self._parser().read_file(f, source, self)
+
+    def read_string(self: T, string: str, source="<string>") -> T:
         """Read configuration from a given string.
 
         Args:
             string (str): string containing a configuration
             source (str): reference name for file object, default '<string>'
         """
-        sfile = io.StringIO(string)
-        self.read_file(sfile, source)
+        self.remove_all()
+        return self._parser().read_string(string, source, self)
 
     def optionxform(self, optionstr) -> str:
         """Converts an option key to lower case for unification
@@ -116,10 +139,10 @@ def write(self, fp: TextIO, validate: bool = True):
             validate (Boolean): validate format before writing
         """
         if validate:
-            self.validate_format()
+            self.validate_format(**self._parser_opts)
         fp.write(str(self))
 
-    def update_file(self, validate: bool = True):
+    def update_file(self: T, validate: bool = True) -> T:
         """Update the read-in configuration file.
 
         Args:
@@ -128,6 +151,7 @@ def update_file(self, validate: bool = True):
         if self._filename is None:
             raise NoConfigFileReadError()
         if validate:  # validate BEFORE opening the file!
-            self.validate_format()
+            self.validate_format(**self._parser_opts)
         with open(self._filename, "w") as fb:
             self.write(fb, validate=False)
+        return self

src/configupdater/container.py

@@ -1,5 +1,6 @@
 import sys
 from abc import ABC
+from textwrap import indent
 from typing import Generic, Optional, TypeVar
 
 if sys.version_info[:2] >= (3, 9):
@@ -19,6 +20,14 @@ class Container(ABC, Generic[T]):
     def __init__(self):
         self._structure: List[T] = []
 
+    def _repr_blocks(self) -> str:
+        blocks = "\n".join(repr(block) for block in self._structure)
+        blocks = indent(blocks, " " * 4)
+        return f"[\n{blocks.rstrip()}\n]" if blocks.strip() else "[]"
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self._repr_blocks()}>"
+
     @property
     def structure(self) -> List[T]:
         return self._structure
@@ -53,3 +62,11 @@ def iter_blocks(self) -> Iterator[T]:
     def __len__(self) -> int:
         """Number of blocks in container"""
         return len(self._structure)
+
+    def append(self: C, block: T) -> C:
+        self._structure.append(block)
+        return self
+
+    def remove_all(self: C) -> C:
+        self._structure.clear()
+        return self

src/configupdater/document.py

@@ -59,17 +59,9 @@ def validate_format(self, **kwargs):
         Args:
             kwargs: are passed to :class:`configparser.ConfigParser`
         """
-        args = dict(
-            dict_type=self._dict,
-            allow_no_value=self._allow_no_value,
-            inline_comment_prefixes=self._inline_comment_prefixes,
-            strict=self._strict,
-            empty_lines_in_values=self._empty_lines_in_values,
-        )
-        args.update(kwargs)
-        parser = ConfigParser(**args)
-        updated_cfg = str(self)
-        parser.read_string(updated_cfg)
+        kwargs.pop("space_around_delimiters", None)
+        parser = ConfigParser(**kwargs)
+        parser.read_string(str(self))
 
     def iter_sections(self) -> Iterator[Section]:
         """Iterate only over section blocks"""

src/configupdater/option.py

@@ -72,7 +72,7 @@ def __str__(self) -> str:
         return "{}{}{}{}".format(self._key, delim, self._value, "\n")
 
     def __repr__(self) -> str:
-        return "<Option: {} = {}>".format(self.key, self.value)
+        return f"<Option: {self._key} = {self.value!r}>"
 
     @property
     def key(self) -> str: