Extract method for _raise_all and yield ParseErrors from _read_inner.

Reduces complexity by 1 and reduces touch points for handling errors in _read_inner.
python · jaraco · Mar 29, 2024 · Mar 27, 2024 · Mar 27, 2024 · Mar 27, 2024
commit 1e69aaecf0ae53540b798b698ee2ca7a7a243aab
@@ -302,15 +302,23 @@ def __init__(self, option, section, rawval):
 class ParsingError(Error):
     """Raised when a configuration file does not follow legal syntax."""
 
-    def __init__(self, source):
+    def __init__(self, source, *args):
         super().__init__(f'Source contains parsing errors: {source!r}')
         self.source = source
         self.errors = []
         self.args = (source, )
+        if args:
+            self.append(*args)
 
     def append(self, lineno, line):
         self.errors.append((lineno, line))
-        self.message += '\n\t[line %2d]: %s' % (lineno, line)
+        self.message += '\n\t[line %2d]: %s' % (lineno, repr(line))
+
+    def combine(self, others):
+        for other in others:
+            for error in other.errors:
+                self.append(*error)
+        return self
 
 
 class MissingSectionHeaderError(ParsingError):
@@ -977,18 +985,25 @@ def _read(self, fp, fpname):
         """
 
         try:
-            self._read_inner(fp, fpname)
+            self._raise_all(*self._read_inner(fp, fpname))
         finally:
             self._join_multiline_values()
 
+    def _raise_all(self, *exceptions: ParsingError):
+        """
+        Combine any number of ParsingErrors into one and raise it.
+        """
+        if not exceptions:
+            return
+        raise exceptions[0].combine(exceptions[1:])
+
     def _read_inner(self, fp, fpname):
         elements_added = set()
         cursect = None                        # None, or a dictionary
         sectname = None
         optname = None
         lineno = 0
         indent_level = 0
-        e = None                              # None, or an exception
 
         for lineno, line in enumerate(fp, start=1):
             comment_start = sys.maxsize
@@ -1096,7 +1111,7 @@ def _read_inner(self, fp, fpname):
                         if mo:
                             optname, vi, optval = mo.group('option', 'vi', 'value')
                             if not optname:
-                                e = self._handle_error(e, fpname, lineno, line)
+                                yield ParsingError(fpname, lineno, line)
                             optname = self.optionxform(optname.rstrip())
                             if (self._strict and
                                 (sectname, optname) in elements_added):
@@ -1116,11 +1131,7 @@ def _read_inner(self, fp, fpname):
                             # exception but keep going. the exception will be
                             # raised at the end of the file and will contain a
                             # list of all bogus lines
-                            e = self._handle_error(e, fpname, lineno, line)
-
-        # if any parsing errors occurred, raise an exception
-        if e:
-            raise e
+                            yield ParsingError(fpname, lineno, line)
 
 
     def _join_multiline_values(self):
@@ -1141,12 +1152,6 @@ def _read_defaults(self, defaults):
         for key, value in defaults.items():
             self._defaults[self.optionxform(key)] = value
 
-    def _handle_error(self, exc, fpname, lineno, line):
-        if not exc:
-            exc = ParsingError(fpname)
-        exc.append(lineno, repr(line))
-        return exc
-
     def _unify_values(self, section, vars):
         """Create a sequence of lookups with 'vars' taking priority over
         the 'section' which takes priority over the DEFAULTSECT.