Add IniConfig.parse() classmethod to fix inline comment handling

Fixes #55 - Inline comments were incorrectly included in parsed values

The bug: Inline comments (# or ;) were being included as part of values
instead of being stripped, inconsistent with how section comments are handled.

Example of the bug:
  name = value # comment
  Result was: "value # comment" (incorrect)
  Should be: "value" (correct)

Changes:
- Add IniConfig.parse() classmethod with strip_inline_comments parameter
  - Default: strip_inline_comments=True (correct behavior - strips comments)
  - Can set strip_inline_comments=False if old buggy behavior needed
- IniConfig() constructor preserves old behavior for backward compatibility
  (calls parse_ini_data with strip_inline_comments=False)
- Add parse_ini_data() helper in _parse.py to avoid code duplication
- Update _parseline() to support strip_inline_comments parameter
- Add comprehensive tests for both correct and legacy behavior

Backward compatibility: Existing code using IniConfig() continues to work
unchanged. Users should migrate to IniConfig.parse() for correct behavior.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: RonnyPfannschmidt

CHANGELOG

@@ -1,3 +1,12 @@
+2.3.0
+=====
+
+* add IniConfig.parse() classmethod with strip_inline_comments parameter (fixes #55)
+  - by default (strip_inline_comments=True), inline comments are properly stripped from values
+  - set strip_inline_comments=False to preserve old behavior if needed
+* IniConfig() constructor maintains backward compatibility (does not strip inline comments)
+* users should migrate to IniConfig.parse() for correct comment handling
+
 2.2.0
 =====
 

src/iniconfig/__init__.py

@@ -102,27 +102,61 @@ def __init__(
             with open(self.path, encoding=encoding) as fp:
                 data = fp.read()
 
-        tokens = _parse.parse_lines(self.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:
-                raise ParseError(self.path, lineno, "no section header defined")
-            self._sources[section, name] = lineno
-            if name is None:
-                if section in self.sections:
-                    raise ParseError(
-                        self.path, lineno, f"duplicate section {section!r}"
-                    )
-                sections_data[section] = {}
-            else:
-                if name in self.sections[section]:
-                    raise ParseError(self.path, lineno, f"duplicate name {name!r}")
-                assert value is not None
-                sections_data[section][name] = value
+        # Use old behavior (no stripping) for backward compatibility
+        sections_data, sources = _parse.parse_ini_data(
+            self.path, data, strip_inline_comments=False
+        )
+
+        self._sources = sources
+        self.sections = sections_data
+
+    @classmethod
+    def parse(
+        cls,
+        path: str | os.PathLike[str],
+        data: str | None = None,
+        encoding: str = "utf-8",
+        *,
+        strip_inline_comments: bool = True,
+    ) -> "IniConfig":
+        """Parse an INI file.
+
+        Args:
+            path: Path to the INI file (used for error messages)
+            data: Optional INI content as string. If None, reads from path.
+            encoding: Encoding to use when reading the file (default: utf-8)
+            strip_inline_comments: Whether to strip inline comments from values
+                (default: True). When True, comments starting with # or ; are
+                removed from values, matching the behavior for section comments.
+
+        Returns:
+            IniConfig instance with parsed configuration
+
+        Example:
+            # With comment stripping (default):
+            config = IniConfig.parse("setup.cfg")
+            # value = "foo" instead of "foo # comment"
+
+            # Without comment stripping (old behavior):
+            config = IniConfig.parse("setup.cfg", strip_inline_comments=False)
+            # value = "foo # comment"
+        """
+        fspath = os.fspath(path)
+
+        if data is None:
+            with open(fspath, encoding=encoding) as fp:
+                data = fp.read()
+
+        sections_data, sources = _parse.parse_ini_data(
+            fspath, data, strip_inline_comments=strip_inline_comments
+        )
+
+        # Create instance directly without calling __init__
+        instance = cls.__new__(cls)
+        object.__setattr__(instance, "path", fspath)
+        object.__setattr__(instance, "sections", sections_data)
+        object.__setattr__(instance, "_sources", sources)
+        return instance
 
     def lineof(self, section: str, name: str | None = None) -> int | None:
         lineno = self._sources.get((section, name))

src/iniconfig/_parse.py

@@ -1,3 +1,4 @@
+from collections.abc import Mapping
 from typing import NamedTuple
 
 from .exceptions import ParseError
@@ -12,11 +13,55 @@ class ParsedLine(NamedTuple):
     value: str | None
 
 
-def parse_lines(path: str, line_iter: list[str]) -> list[ParsedLine]:
+def parse_ini_data(
+    path: str,
+    data: str,
+    *,
+    strip_inline_comments: bool,
+) -> tuple[Mapping[str, Mapping[str, str]], Mapping[tuple[str, str | None], int]]:
+    """Parse INI data and return sections and sources mappings.
+
+    Args:
+        path: Path for error messages
+        data: INI content as string
+        strip_inline_comments: Whether to strip inline comments from values
+
+    Returns:
+        Tuple of (sections_data, sources) where:
+        - sections_data: mapping of section -> {name -> value}
+        - sources: mapping of (section, name) -> line number
+    """
+    tokens = parse_lines(
+        path, data.splitlines(True), strip_inline_comments=strip_inline_comments
+    )
+
+    sources: dict[tuple[str, str | None], int] = {}
+    sections_data: dict[str, dict[str, str]] = {}
+
+    for lineno, section, name, value in tokens:
+        if section is None:
+            raise ParseError(path, lineno, "no section header defined")
+        sources[section, name] = lineno
+        if name is None:
+            if section in sections_data:
+                raise ParseError(path, lineno, f"duplicate section {section!r}")
+            sections_data[section] = {}
+        else:
+            if name in sections_data[section]:
+                raise ParseError(path, lineno, f"duplicate name {name!r}")
+            assert value is not None
+            sections_data[section][name] = value
+
+    return sections_data, sources
+
+
+def parse_lines(
+    path: str, line_iter: list[str], *, strip_inline_comments: bool = False
+) -> list[ParsedLine]:
     result: list[ParsedLine] = []
     section = None
     for lineno, line in enumerate(line_iter):
-        name, data = _parseline(path, line, lineno)
+        name, data = _parseline(path, line, lineno, strip_inline_comments)
         # new value
         if name is not None and data is not None:
             result.append(ParsedLine(lineno, section, name, data))
@@ -42,7 +87,9 @@ def parse_lines(path: str, line_iter: list[str]) -> list[ParsedLine]:
     return result
 
 
-def _parseline(path: str, line: str, lineno: int) -> tuple[str | None, str | None]:
+def _parseline(
+    path: str, line: str, lineno: int, strip_inline_comments: bool
+) -> tuple[str | None, str | None]:
     # blank lines
     if iscommentline(line):
         line = ""
@@ -69,10 +116,20 @@ def _parseline(path: str, line: str, lineno: int) -> tuple[str | None, str | Non
                 name, value = line.split(":", 1)
             except ValueError:
                 raise ParseError(path, lineno, f"unexpected line: {line!r}") from None
-        return name.strip(), value.strip()
+        value = value.strip()
+        # Strip inline comments from values if requested (issue #55)
+        if strip_inline_comments:
+            for c in COMMENTCHARS:
+                value = value.split(c)[0].rstrip()
+        return name.strip(), value
     # continuation
     else:
-        return None, line.strip()
+        line = line.strip()
+        # Strip inline comments from continuations if requested (issue #55)
+        if strip_inline_comments:
+            for c in COMMENTCHARS:
+                line = line.split(c)[0].rstrip()
+        return None, line
 
 
 def iscommentline(line: str) -> bool:

testing/test_iniconfig.py

@@ -125,7 +125,7 @@ def test_iniconfig_from_file(tmp_path: Path) -> None:
     config = IniConfig(str(path), "[diff]")
     assert list(config.sections) == ["diff"]
     with pytest.raises(TypeError):
-        IniConfig(data=path.read_text())  # type: ignore
+        IniConfig(data=path.read_text())  # type: ignore[call-arg]
 
 
 def test_iniconfig_section_first() -> None:
@@ -304,3 +304,75 @@ def test_api_import() -> None:
 )
 def test_iscommentline_true(line: str) -> None:
     assert iscommentline(line)
+
+
+def test_parse_strips_inline_comments() -> None:
+    """Test that IniConfig.parse() strips inline comments from values by default."""
+    config = IniConfig.parse(
+        "test.ini",
+        data=dedent(
+            """
+            [section1]
+            name1 = value1 # this is a comment
+            name2 = value2 ; this is also a comment
+            name3 = value3# no space before comment
+            list = a, b, c # some items
+            """
+        ),
+    )
+    assert config["section1"]["name1"] == "value1"
+    assert config["section1"]["name2"] == "value2"
+    assert config["section1"]["name3"] == "value3"
+    assert config["section1"]["list"] == "a, b, c"
+
+
+def test_parse_strips_inline_comments_from_continuations() -> None:
+    """Test that inline comments are stripped from continuation lines."""
+    config = IniConfig.parse(
+        "test.ini",
+        data=dedent(
+            """
+            [section]
+            names =
+                Alice # first person
+                Bob ; second person
+                Charlie
+            """
+        ),
+    )
+    assert config["section"]["names"] == "Alice\nBob\nCharlie"
+
+
+def test_parse_preserves_inline_comments_when_disabled() -> None:
+    """Test that IniConfig.parse(strip_inline_comments=False) preserves comments."""
+    config = IniConfig.parse(
+        "test.ini",
+        data=dedent(
+            """
+            [section1]
+            name1 = value1 # this is a comment
+            name2 = value2 ; this is also a comment
+            list = a, b, c # some items
+            """
+        ),
+        strip_inline_comments=False,
+    )
+    assert config["section1"]["name1"] == "value1 # this is a comment"
+    assert config["section1"]["name2"] == "value2 ; this is also a comment"
+    assert config["section1"]["list"] == "a, b, c # some items"
+
+
+def test_constructor_preserves_inline_comments_for_backward_compatibility() -> None:
+    """Test that IniConfig() constructor preserves old behavior (no stripping)."""
+    config = IniConfig(
+        "test.ini",
+        data=dedent(
+            """
+            [section1]
+            name1 = value1 # this is a comment
+            name2 = value2 ; this is also a comment
+            """
+        ),
+    )
+    assert config["section1"]["name1"] == "value1 # this is a comment"
+    assert config["section1"]["name2"] == "value2 ; this is also a comment"