move parsing to ownfile

Author: RonnyPfannschmidt

src/iniconfig/__init__.py

@@ -21,26 +21,16 @@
 if TYPE_CHECKING:
     from typing_extensions import Final
 
-__all__ = ["IniConfig", "ParseError"]
+__all__ = ["IniConfig", "ParseError", "COMMENTCHARS", "iscommentline"]
 
 from .exceptions import ParseError
-
-COMMENTCHARS = "#;"
+from . import _parse
+from ._parse import COMMENTCHARS, iscommentline
 
 _D = TypeVar("_D")
 _T = TypeVar("_T")
 
 
-_str_default = cast(Callable[[str], str], str)
-
-
-class _ParsedLine(NamedTuple):
-    lineno: int
-    section: str | None
-    name: str | None
-    value: str | None
-
-
 class SectionWrapper:
     config: Final[IniConfig]
     name: Final[str]
@@ -88,90 +78,26 @@ def __init__(
             with open(self.path, encoding=encoding) as fp:
                 data = fp.read()
 
-        tokens = self._parse(data.splitlines(True))
+        tokens = _parse.parse_lines(path, data.splitlines(True))
 
         self._sources = {}
         sections_data: dict[str, dict[str, str]]
         self.sections = sections_data = {}
 
         for lineno, section, name, value in tokens:
             if section is None:
-                self._raise(lineno, "no section header defined")
+                raise ParseError(path, lineno, "no section header defined")
             self._sources[section, name] = lineno
             if name is None:
                 if section in self.sections:
-                    self._raise(lineno, f"duplicate section {section!r}")
+                    raise ParseError(path, lineno, f"duplicate section {section!r}")
                 sections_data[section] = {}
             else:
                 if name in self.sections[section]:
-                    self._raise(lineno, f"duplicate name {name!r}")
+                    raise ParseError(path, lineno, f"duplicate name {name!r}")
                 assert value is not None
                 sections_data[section][name] = value
 
-    def _raise(self, lineno: int, msg: str) -> NoReturn:
-        raise ParseError(self.path, lineno, msg)
-
-    def _parse(self, line_iter: list[str]) -> list[_ParsedLine]:
-        result: list[_ParsedLine] = []
-        section = None
-        for lineno, line in enumerate(line_iter):
-            name, data = self._parseline(line, lineno)
-            # new value
-            if name is not None and data is not None:
-                result.append(_ParsedLine(lineno, section, name, data))
-            # new section
-            elif name is not None and data is None:
-                if not name:
-                    self._raise(lineno, "empty section name")
-                section = name
-                result.append(_ParsedLine(lineno, section, None, None))
-            # continuation
-            elif name is None and data is not None:
-                if not result:
-                    self._raise(lineno, "unexpected value continuation")
-                last = result.pop()
-                if last.name is None:
-                    self._raise(lineno, "unexpected value continuation")
-
-                if last.value:
-                    last = last._replace(value=f"{last.value}\n{data}")
-                else:
-                    last = last._replace(value=data)
-                result.append(last)
-        return result
-
-    def _parseline(self, line: str, lineno: int) -> tuple[str | None, str | None]:
-        # blank lines
-        if iscommentline(line):
-            line = ""
-        else:
-            line = line.rstrip()
-        if not line:
-            return None, None
-        # section
-        if line[0] == "[":
-            realline = line
-            for c in COMMENTCHARS:
-                line = line.split(c)[0].rstrip()
-            if line[-1] == "]":
-                return line[1:-1], None
-            return None, realline.strip()
-        # value
-        elif not line[0].isspace():
-            try:
-                name, value = line.split("=", 1)
-                if ":" in name:
-                    raise ValueError()
-            except ValueError:
-                try:
-                    name, value = line.split(":", 1)
-                except ValueError:
-                    self._raise(lineno, "unexpected line: %r" % line)
-            return name.strip(), value.strip()
-        # continuation
-        else:
-            return None, line.strip()
-
     def lineof(self, section: str, name: str | None = None) -> int | None:
         lineno = self._sources.get((section, name))
         return None if lineno is None else lineno + 1
@@ -247,8 +173,3 @@ def __iter__(self) -> Iterator[SectionWrapper]:
 
     def __contains__(self, arg: str) -> bool:
         return arg in self.sections
-
-
-def iscommentline(line: str) -> bool:
-    c = line.lstrip()[:1]
-    return c in COMMENTCHARS

src/iniconfig/_parse.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from .exceptions import ParseError
+
+from typing import NamedTuple
+
+
+COMMENTCHARS = "#;"
+
+
+class _ParsedLine(NamedTuple):
+    lineno: int
+    section: str | None
+    name: str | None
+    value: str | None
+
+
+def parse_lines(path: str, line_iter: list[str]) -> list[_ParsedLine]:
+    result: list[_ParsedLine] = []
+    section = None
+    for lineno, line in enumerate(line_iter):
+        name, data = _parseline(path, line, lineno)
+        # new value
+        if name is not None and data is not None:
+            result.append(_ParsedLine(lineno, section, name, data))
+        # new section
+        elif name is not None and data is None:
+            if not name:
+                raise ParseError(path, lineno, "empty section name")
+            section = name
+            result.append(_ParsedLine(lineno, section, None, None))
+        # continuation
+        elif name is None and data is not None:
+            if not result:
+                raise ParseError(path, lineno, "unexpected value continuation")
+            last = result.pop()
+            if last.name is None:
+                raise ParseError(path, lineno, "unexpected value continuation")
+
+            if last.value:
+                last = last._replace(value=f"{last.value}\n{data}")
+            else:
+                last = last._replace(value=data)
+            result.append(last)
+    return result
+
+
+def _parseline(path: str, line: str, lineno: int) -> tuple[str | None, str | None]:
+    # blank lines
+    if iscommentline(line):
+        line = ""
+    else:
+        line = line.rstrip()
+    if not line:
+        return None, None
+    # section
+    if line[0] == "[":
+        realline = line
+        for c in COMMENTCHARS:
+            line = line.split(c)[0].rstrip()
+        if line[-1] == "]":
+            return line[1:-1], None
+        return None, realline.strip()
+    # value
+    elif not line[0].isspace():
+        try:
+            name, value = line.split("=", 1)
+            if ":" in name:
+                raise ValueError()
+        except ValueError:
+            try:
+                name, value = line.split(":", 1)
+            except ValueError:
+                raise ParseError(path, lineno, "unexpected line: %r" % line)
+        return name.strip(), value.strip()
+    # continuation
+    else:
+        return None, line.strip()
+
+
+def iscommentline(line: str) -> bool:
+    c = line.lstrip()[:1]
+    return c in COMMENTCHARS

src/iniconfig/exceptions.py

@@ -1,10 +1,10 @@
-
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing_extensions import Final
 
+
 class ParseError(Exception):
     path: Final[str]
     lineno: Final[int]
@@ -17,4 +17,4 @@ def __init__(self, path: str, lineno: int, msg: str):
         self.msg = msg
 
     def __str__(self) -> str:
-        return f"{self.path}:{self.lineno + 1}: {self.msg}"
+        return f"{self.path}:{self.lineno + 1}: {self.msg}"

testing/test_iniconfig.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import pytest
-from iniconfig import IniConfig, ParseError, __all__ as ALL, _ParsedLine as PL
+from iniconfig import IniConfig, ParseError, __all__ as ALL
+from iniconfig._parse import _ParsedLine as PL
 from iniconfig import iscommentline
 from textwrap import dedent
 from pathlib import Path
@@ -58,12 +59,18 @@ def expected(input_expected: tuple[str, list[PL]]) -> list[PL]:
 
 
 def parse(input: str) -> list[PL]:
-    ini = IniConfig("sample", data="")
-    return ini._parse(input.splitlines(True))
+    from iniconfig._parse import parse_lines
 
+    return parse_lines("sample", input.splitlines(True))
 
-def parse_a_error(input: str) -> pytest.ExceptionInfo[ParseError]:
-    return pytest.raises(ParseError, parse, input)
+
+def parse_a_error(input: str) -> ParseError:
+    try:
+        parse(input)
+    except ParseError as e:
+        return e
+    else:
+        raise ValueError(input)
 
 
 def test_tokenize(input: str, expected: list[PL]) -> None:
@@ -84,18 +91,18 @@ def test_ParseError() -> None:
 
 
 def test_continuation_needs_perceeding_token() -> None:
-    excinfo = parse_a_error(" Foo")
-    assert excinfo.value.lineno == 0
+    err = parse_a_error(" Foo")
+    assert err.lineno == 0
 
 
 def test_continuation_cant_be_after_section() -> None:
-    excinfo = parse_a_error("[section]\n Foo")
-    assert excinfo.value.lineno == 1
+    err = parse_a_error("[section]\n Foo")
+    assert err.lineno == 1
 
 
 def test_section_cant_be_empty() -> None:
-    excinfo = parse_a_error("[]")
-    assert excinfo.value.lineno == 0
+    err = parse_a_error("[]")
+    assert err.lineno == 0
 
 
 @pytest.mark.parametrize(
@@ -282,7 +289,7 @@ def test_example_pypirc() -> None:
 
 
 def test_api_import() -> None:
-    assert ALL == ["IniConfig", "ParseError"]
+    assert ALL == ["IniConfig", "ParseError", "COMMENTCHARS", "iscommentline"]
 
 
 @pytest.mark.parametrize(