From a44f8d947d29438f6483619c97c528166a88d90b Mon Sep 17 00:00:00 2001
From: "GPT 5.6" <codex@openai.com>
Date: Mon, 20 Jul 2026 09:12:55 +0200
Subject: [PATCH] feat: rewrite config parser to be consistent with Git

Previously it was based on an ini-parser, which depends on the
Python version and also isn't actually dealing with the Git's
specific grammar and rules.

Now it's much more consistent, albeit probably also slower.

--- agent

Replace the line-oriented INI parsing logic in GitConfigParser with a
character-stream parser modeled on Git's config.c implementation.

The inherited configparser section matcher treats everything between the
first opening bracket and the last closing bracket as one section name.
Consequently, GitPython interpreted a header such as:

    [user] [other]

as one section named "user] [other", while Git interpreted it as two
successive section headers and assigned following values to "other".
Writing opaque section names through the INI serializer could therefore
change the configuration's meaning when Git subsequently read it.

Implement Git's configuration grammar directly, following the behavior of
git_parse_source(), get_base_var(), get_value(), and parse_value(). The new
parser handles:

- basic and quoted-subsection section headers
- multiple section headers in the same character stream
- comments introduced by '#' or ';'
- quoted and unquoted values
- supported backslash escapes
- backslash-newline continuations
- leading and trailing whitespace rules
- CRLF input and UTF-8 byte-order marks
- entries without values, represented semantically as boolean true
- duplicate options while preserving their order

Reject syntax that Git itself rejects, including colon delimiters,
underscore-containing option names, malformed section headers, unknown
value escapes, and unterminated quoted values.

Replace the raw value writer with a canonical Git-config serializer.
Values are always quoted, with backslashes, quotes, newlines, tabs, and
backspaces escaped. Quoted subsection names are parsed and re-escaped
canonically before being written. Comments and original whitespace remain
intentionally unpreserved when a dirty configuration is flushed.

Validate section names by parsing them as complete Git section headers.
This ensures each supplied name identifies exactly one section and
prevents unquoted closing brackets from injecting another section.
Validate option names against Git's ASCII letter, digit, and hyphen
grammar as well.

Update fixtures that previously depended on INI syntax rejected by Git,
and adjust expectations for decoded value escapes and valueless boolean
entries.

Add coverage for:

- the differing interpretation of adjacent section headers
- BOM, CRLF, comments, continuations, and valueless entries
- malformed syntax rejected by Git
- canonical value serialization and reparsing
- real `git config` interoperability
- closing brackets inside quoted subsection names
- quotes and backslashes inside subsection names
- invalid section and option names
- duplicate-value behavior with Git-compatible option names

Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>
---
 git/config.py                                | 867 +++++++++++++------
 git/objects/submodule/base.py                |   7 +-
 git/objects/submodule/util.py                |   2 +-
 git/remote.py                                |   9 +-
 test/fixtures/git_config                     |   4 +-
 test/fixtures/git_config_multiple            |   2 +-
 test/fixtures/git_config_with_quotes_escapes |   2 -
 test/test_config.py                          | 332 +++++--
 test/test_submodule.py                       |   9 +-
 9 files changed, 846 insertions(+), 388 deletions(-)

diff --git a/git/config.py b/git/config.py
index 821710ea3..8f94d1d9d 100644
--- a/git/config.py
+++ b/git/config.py
@@ -7,11 +7,18 @@
 
 __all__ = ["GitConfigParser", "SectionConstraint"]
 
-import abc
-import configparser as cp
+from collections import OrderedDict
+from collections.abc import MutableMapping
+from configparser import (
+    DuplicateSectionError,
+    Error as ConfigError,
+    MissingSectionHeaderError,
+    NoOptionError,
+    NoSectionError,
+    ParsingError,
+)
 import fnmatch
 from functools import wraps
-import inspect
 from io import BufferedReader, IOBase
 import logging
 import os
@@ -29,8 +36,10 @@
     Callable,
     Generic,
     IO,
+    Iterator,
     List,
     Dict,
+    NoReturn,
     Sequence,
     TYPE_CHECKING,
     Tuple,
@@ -47,17 +56,6 @@
     from git.repo.base import Repo
 
 T_ConfigParser = TypeVar("T_ConfigParser", bound="GitConfigParser")
-T_OMD_value = TypeVar("T_OMD_value", str, bytes, int, float, bool)
-
-if sys.version_info[:3] < (3, 7, 2):
-    # typing.Ordereddict not added until Python 3.7.2.
-    from collections import OrderedDict
-
-    OrderedDict_OMD = OrderedDict
-else:
-    from typing import OrderedDict
-
-    OrderedDict_OMD = OrderedDict[str, List[T_OMD_value]]  # type: ignore[assignment, misc]
 
 # -------------------------------------------------------------
 
@@ -66,45 +64,225 @@
 CONFIG_LEVELS: ConfigLevels_Tup = ("system", "user", "global", "repository")
 """The configuration level of a configuration file."""
 
-CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbranch|hasconfig:remote\.\*\.url):(.+)\"")
+CONDITIONAL_INCLUDE_REGEXP = re.compile(
+    r'(?<=includeif )"(gitdir|gitdir/i|onbranch|hasconfig:remote\.\*\.url):(.+)"',
+    re.IGNORECASE,
+)
 """Section pattern to detect conditional includes.
 
 See: https://git-scm.com/docs/git-config#_conditional_includes
 """
 
 UNSAFE_CONFIG_CHARS_RE = re.compile(r"[\r\n\x00]")
-"""Characters that cannot be safely written in config names or values."""
+"""Characters that cannot be safely written in config names."""
 
+UNSAFE_CONFIG_VALUE_CHARS_RE = re.compile(r"\x00")
+"""Characters that cannot be represented in Git config values."""
 
-class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
-    """Utility class wrapping base-class methods into decorators that assure read-only
-    properties."""
+_MISSING = object()
 
-    def __new__(cls, name: str, bases: Tuple, clsdict: Dict[str, Any]) -> "MetaParserBuilder":
-        """Equip all base-class methods with a needs_values decorator, and all non-const
-        methods with a :func:`set_dirty_and_flush_changes` decorator in addition to
-        that.
-        """
-        kmm = "_mutating_methods_"
-        if kmm in clsdict:
-            mutating_methods = clsdict[kmm]
-            for base in bases:
-                methods = (t for t in inspect.getmembers(base, inspect.isroutine) if not t[0].startswith("_"))
-                for method_name, method in methods:
-                    if method_name in clsdict:
-                        continue
-                    method_with_values = needs_values(method)
-                    if method_name in mutating_methods:
-                        method_with_values = set_dirty_and_flush_changes(method_with_values)
-                    # END mutating methods handling
 
-                    clsdict[method_name] = method_with_values
-                # END for each name/method pair
-            # END for each base
-        # END if mutating methods configuration is set
+def _escape_section_subsection(value: str) -> str:
+    """Return *value* escaped for Git's double-quoted subsection syntax."""
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
 
-        new_type = super().__new__(cls, name, bases, clsdict)
-        return new_type
+def _escape_config_value(value: str) -> str:
+    """Return *value* in a canonical representation accepted by Git."""
+    escaped = value.replace("\\", "\\\\")
+    escaped = escaped.replace('"', '\\"')
+    escaped = escaped.replace("\n", "\\n").replace("\t", "\\t").replace("\b", "\\b")
+    return '"%s"' % escaped
+
+
+class _GitConfigFileParser:
+    """Parse Git config syntax using the grammar in Git's ``config.c``.
+
+    The state machine mirrors Git's ``git_parse_source()``, ``get_base_var()``,
+    ``get_value()``, and ``parse_value()``. It intentionally deals only with syntax;
+    includes are resolved by :class:`GitConfigParser` after each file is parsed.
+    """
+
+    def __init__(self, data: str, source: str) -> None:
+        self._data = data[1:] if data.startswith("\ufeff") else data
+        self._source = source
+        self._position = 0
+        self._line_number = 1
+        self._current_section: Union[str, None] = None
+
+    @staticmethod
+    def _is_key_char(char: str) -> bool:
+        return char.isascii() and (char.isalnum() or char == "-")
+
+    @staticmethod
+    def _is_space(char: str) -> bool:
+        return char in " \t\n\v\f\r"
+
+    def _get_char(self) -> Union[str, None]:
+        if self._position == len(self._data):
+            return None
+
+        char = self._data[self._position]
+        self._position += 1
+        if char == "\r" and self._position < len(self._data) and self._data[self._position] == "\n":
+            self._position += 1
+            char = "\n"
+        if char == "\n":
+            self._line_number += 1
+        return char
+
+    def _error(self, line_number: Union[int, None] = None) -> NoReturn:
+        number = self._line_number if line_number is None else line_number
+        lines = self._data.splitlines()
+        line = lines[number - 1] if 0 < number <= len(lines) else ""
+        error = ParsingError(self._source)
+        error.append(number, repr(line))
+        raise error
+
+    def _parse_section(self, line_number: int) -> str:
+        base: List[str] = []
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                self._error(line_number)
+            if char == "]":
+                if not base:
+                    self._error(line_number)
+                return "".join(base)
+            if self._is_space(char):
+                break
+            if not self._is_key_char(char) and char != ".":
+                self._error(line_number)
+            base.append(char)
+
+        while char is not None and self._is_space(char) and char != "\n":
+            char = self._get_char()
+        if char != '"' or not base:
+            self._error(line_number)
+
+        subsection: List[str] = []
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                self._error(line_number)
+            if char == '"':
+                break
+            if char == "\\":
+                char = self._get_char()
+                if char is None or char == "\n":
+                    self._error(line_number)
+            subsection.append(char)
+
+        if self._get_char() != "]":
+            self._error(line_number)
+        return '%s "%s"' % ("".join(base), _escape_section_subsection("".join(subsection)))
+
+    def _parse_value(self, line_number: int) -> str:
+        value: List[str] = []
+        pending_whitespace: List[str] = []
+        quoted = False
+        comment = False
+
+        while True:
+            char = self._get_char()
+            if char is None or char == "\n":
+                if quoted:
+                    self._error(line_number)
+                return "".join(value)
+            if char == "\x00":
+                self._error(line_number)
+            if comment:
+                continue
+            if self._is_space(char) and not quoted:
+                if value:
+                    pending_whitespace.append(char)
+                continue
+            if not quoted and char in ";#":
+                comment = True
+                continue
+
+            if pending_whitespace:
+                value.extend(pending_whitespace)
+                pending_whitespace = []
+            if char == "\\":
+                char = self._get_char()
+                if char is None:
+                    self._error(line_number)
+                if char == "\n":
+                    continue
+                escapes = {"t": "\t", "b": "\b", "n": "\n", "\\": "\\", '"': '"'}
+                if char not in escapes:
+                    self._error(line_number)
+                value.append(escapes[char])
+            elif char == '"':
+                quoted = not quoted
+            else:
+                value.append(char)
+
+    def _parse_entry(self, first_char: str, line_number: int) -> Tuple[str, Union[str, None]]:
+        option = [first_char]
+        char = self._get_char()
+        while char is not None and self._is_key_char(char):
+            option.append(char)
+            char = self._get_char()
+        while char in (" ", "\t"):
+            char = self._get_char()
+
+        # Git distinguishes a valueless key from a key whose value is "true".
+        if char is None or char == "\n":
+            return "".join(option), None
+        if char != "=":
+            self._error(line_number)
+        return "".join(option), self._parse_value(line_number)
+
+    def parse(self) -> List[Tuple[str, Union[str, None], Union[str, None]]]:
+        events: List[Tuple[str, Union[str, None], Union[str, None]]] = []
+        comment = False
+
+        while True:
+            line_number = self._line_number
+            char = self._get_char()
+            if char is None:
+                return events
+            if char == "\n":
+                comment = False
+                continue
+            if comment:
+                continue
+            if self._is_space(char):
+                continue
+            if char in "#;":
+                comment = True
+                continue
+            if char == "[":
+                self._current_section = self._parse_section(line_number)
+                events.append((self._current_section, None, None))
+                continue
+            if not (char.isascii() and char.isalpha()):
+                self._error(line_number)
+            if self._current_section is None:
+                line = self._data.splitlines()[line_number - 1]
+                raise MissingSectionHeaderError(self._source, line_number, line)
+            option, value = self._parse_entry(char, line_number)
+            events.append((self._current_section, option, value))
+
+
+def _canonical_section_name(name: str) -> str:
+    """Validate and canonicalize one section name using Git's own grammar."""
+    events = _GitConfigFileParser("[%s]" % name, "<section name>").parse()
+    sections = [section for section, option, _ in events if option is None]
+    if len(sections) != 1:
+        raise ValueError("Git config section name does not identify exactly one section")
+    return sections[0]
+
+
+def _section_name_key(name: str) -> str:
+    """Return Git's case-insensitive lookup key for a canonical section name."""
+    canonical_name = _canonical_section_name(name)
+    subsection_start = canonical_name.find(' "')
+    if subsection_start == -1:
+        return canonical_name.lower()
+    return canonical_name[:subsection_start].lower() + canonical_name[subsection_start:]
 
 
 def needs_values(func: Callable[..., _T]) -> Callable[..., _T]:
@@ -139,13 +317,12 @@ def flush_changes(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
 
 
 class SectionConstraint(Generic[T_ConfigParser]):
-    """Constrains a ConfigParser to only option commands which are constrained to
-    always use the section we have been initialized with.
+    """Constrain a configuration parser to commands for one section.
 
-    It supports all ConfigParser methods that operate on an option.
+    It supports all :class:`GitConfigParser` methods that operate on an option.
 
     :note:
-        If used as a context manager, will release the wrapped ConfigParser.
+        If used as a context manager, this releases the wrapped parser.
     """
 
     __slots__ = ("_config", "_section_name")
@@ -186,7 +363,7 @@ def _call_config(self, method: str, *args: Any, **kwargs: Any) -> Any:
 
     @property
     def config(self) -> T_ConfigParser:
-        """return: ConfigParser instance we constrain"""
+        """Return the :class:`GitConfigParser` instance being constrained."""
         return self._config
 
     def release(self) -> None:
@@ -202,49 +379,94 @@ def __exit__(self, exception_type: str, exception_value: str, traceback: str) ->
         self._config.__exit__(exception_type, exception_value, traceback)
 
 
-class _OMD(OrderedDict_OMD):
-    """Ordered multi-dict."""
+class _GitConfigSectionData:
+    """Ordered, multi-valued storage for one Git configuration section."""
 
-    def __setitem__(self, key: str, value: _T) -> None:
-        super().__setitem__(key, [value])
+    def __init__(self) -> None:
+        self._values: "OrderedDict[str, List[Union[str, None]]]" = OrderedDict()
 
-    def add(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
+    def __contains__(self, option: str) -> bool:
+        return option in self._values
 
-        super().__getitem__(key).append(value)
+    def __len__(self) -> int:
+        return len(self._values)
 
-    def setall(self, key: str, values: List[_T]) -> None:
-        super().__setitem__(key, values)
+    def add(self, option: str, value: Union[str, None]) -> None:
+        self._values.setdefault(option, []).append(value)
 
-    def __getitem__(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
+    def set(self, option: str, value: Union[str, None]) -> None:
+        self._values[option] = [value]
 
-    def getlast(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
+    def setall(self, option: str, values: List[Union[str, None]]) -> None:
+        self._values[option] = list(values)
+
+    def getlast(self, option: str) -> Union[str, None]:
+        return self._values[option][-1]
+
+    def getall(self, option: str) -> List[Union[str, None]]:
+        return list(self._values[option])
+
+    def remove(self, option: str) -> bool:
+        if option not in self._values:
+            return False
+        del self._values[option]
+        return True
+
+    def options(self) -> List[str]:
+        return list(self._values)
+
+    def items_all(self) -> List[Tuple[str, List[Union[str, None]]]]:
+        return [(option, list(values)) for option, values in self._values.items()]
 
-    def setlast(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
 
-        prior = super().__getitem__(key)
-        prior[-1] = value
+class _GitConfigSection(MutableMapping):
+    """Mapping-style view of one section in a :class:`GitConfigParser`."""
 
-    def get(self, key: str, default: Union[_T, None] = None) -> Union[_T, None]:
-        return super().get(key, [default])[-1]
+    def __init__(self, parser: "GitConfigParser", name: str) -> None:
+        self._parser = parser
+        self._name = name
 
-    def getall(self, key: str) -> List[_T]:
-        return super().__getitem__(key)
+    def __repr__(self) -> str:
+        return "<Git config section: %s>" % self._name
 
-    def items(self) -> List[Tuple[str, _T]]:  # type: ignore[override]
-        """List of (key, last value for key)."""
-        return [(k, self[k]) for k in self]
+    def __getitem__(self, option: str) -> str:
+        return self._parser.get(self._name, option)
 
-    def items_all(self) -> List[Tuple[str, List[_T]]]:
-        """List of (key, list of values for key)."""
-        return [(k, self.getall(k)) for k in self]
+    def __setitem__(self, option: str, value: Any) -> None:
+        self._parser.set(self._name, option, value)
+
+    def __delitem__(self, option: str) -> None:
+        if not self._parser.remove_option(self._name, option):
+            raise KeyError(option)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._parser.options(self._name))
+
+    def __len__(self) -> int:
+        return len(self._parser.options(self._name))
+
+    def __contains__(self, option: object) -> bool:
+        return isinstance(option, str) and self._parser.has_option(self._name, option)
+
+    def get(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:  # type: ignore[override]
+        return self._parser.get(self._name, option, fallback=fallback, **kwargs)
+
+    def getint(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getint(self._name, option, fallback=fallback, **kwargs)
+
+    def getfloat(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getfloat(self._name, option, fallback=fallback, **kwargs)
+
+    def getboolean(self, option: str, fallback: Any = None, **kwargs: Any) -> Any:
+        return self._parser.getboolean(self._name, option, fallback=fallback, **kwargs)
+
+    @property
+    def parser(self) -> "GitConfigParser":
+        return self._parser
+
+    @property
+    def name(self) -> str:
+        return self._name
 
 
 def get_config_path(config_level: Lit_config_levels) -> str:
@@ -271,7 +493,7 @@ def get_config_path(config_level: Lit_config_levels) -> str:
         )
 
 
-class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
+class GitConfigParser:
     """Implements specifics required to read git style configuration files.
 
     This variation behaves much like the :manpage:`git-config(1)` command, such that the
@@ -285,8 +507,8 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
     other instances to write concurrently.
 
     :note:
-        The config is case-sensitive even when queried, hence section and option names
-        must match perfectly.
+        Section and option names are case-insensitive, while subsection names are
+        case-sensitive, matching Git.
 
     :note:
         If used as a context manager, this will release the locked file.
@@ -300,21 +522,6 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
     A suitable alternative would be the :class:`~git.util.BlockingLockFile`.
     """
 
-    re_comment = re.compile(r"^\s*[#;]")
-    # } END configuration
-
-    optvalueonly_source = r"\s*(?P<option>[^:=\s][^:=]*)"
-
-    OPTVALUEONLY = re.compile(optvalueonly_source)
-
-    OPTCRE = re.compile(optvalueonly_source + r"\s*(?P<vi>[:=])\s*" + r"(?P<value>.*)$")
-
-    del optvalueonly_source
-
-    _mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")
-    """Names of :class:`~configparser.RawConfigParser` methods able to change the
-    instance."""
-
     def __init__(
         self,
         file_or_files: Union[None, PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = None,
@@ -330,9 +537,9 @@ def __init__(
             A file path or file object, or a sequence of possibly more than one of them.
 
         :param read_only:
-            If ``True``, the ConfigParser may only read the data, but not change it.
+            If ``True``, the parser may only read the data, but not change it.
             If ``False``, only a single file path or file object may be given. We will
-            write back the changes when they happen, or when the ConfigParser is
+            write back the changes when they happen, or when the parser is
             released. This will not happen if other configuration files have been
             included.
 
@@ -347,15 +554,11 @@ def __init__(
             Reference to repository to use if ``[includeIf]`` sections are found in
             configuration files.
         """
-        cp.RawConfigParser.__init__(self, dict_type=_OMD)
-        self._dict: Callable[..., _OMD]
-        self._defaults: _OMD
-        self._sections: _OMD
-
-        # Used in Python 3. Needs to stay in sync with sections for underlying
-        # implementation to work.
-        if not hasattr(self, "_proxies"):
-            self._proxies = self._dict()
+        self._sections: "OrderedDict[str, _GitConfigSectionData]" = OrderedDict()
+        # Lookups use case-normalized keys, while canonical rewrites retain the
+        # first spelling seen in the file or supplied through the API.
+        self._section_name_map: Dict[str, str] = {}
+        self._option_name_map: Dict[Tuple[str, str], str] = {}
 
         if file_or_files is not None:
             self._file_or_files: Union[PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = file_or_files
@@ -385,7 +588,7 @@ def _acquire_lock(self) -> None:
                     file_or_files = self._file_or_files
                 elif isinstance(self._file_or_files, (tuple, list, Sequence)):
                     raise ValueError(
-                        "Write-ConfigParsers can operate on a single file only, multiple files have been passed"
+                        "Writable config parsers can operate on a single file only; multiple files were passed"
                     )
                 else:
                     file_or_files = self._file_or_files.name
@@ -436,112 +639,131 @@ def release(self) -> None:
                 self._lock._release_lock()
 
     def optionxform(self, optionstr: str) -> str:
-        """Do not transform options in any way when writing."""
-        return optionstr
+        """Normalize option names as Git does; their spelling is case-insensitive."""
+        return optionstr.lower()
 
-    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
-        """Originally a direct copy of the Python 2.4 version of
-        :meth:`RawConfigParser._read <configparser.RawConfigParser._read>`, to ensure it
-        uses ordered dicts.
+    @needs_values
+    def sections(self) -> List[str]:
+        """Return section names with the spelling used in the configuration."""
+        return [self._section_name_map.get(section, section) for section in self._sections]
 
-        The ordering bug was fixed in Python 2.4, and dict itself keeps ordering since
-        Python 3.7. This has some other changes, especially that it ignores initial
-        whitespace, since git uses tabs. (Big comments are removed to be more compact.)
-        """
-        cursect = None  # None, or a dictionary.
-        optname = None
-        lineno = 0
-        is_multi_line = False
-        e = None  # None, or an exception.
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over section names with their original spelling."""
+        return iter(self.sections())
 
-        def string_decode(v: str) -> str:
-            if v and v.endswith("\\"):
-                v = v[:-1]
-            # END cut trailing escapes to prevent decode error
+    def __len__(self) -> int:
+        self.read()
+        return len(self._sections)
 
-            return v.encode(defenc).decode("unicode_escape")
+    def __contains__(self, section: object) -> bool:
+        return isinstance(section, str) and self.has_section(section)
 
-        # END string_decode
+    @needs_values
+    def __getitem__(self, section: str) -> _GitConfigSection:
+        """Return a section proxy using Git's section case rules."""
+        section_key = self._normalize_section_name(section)
+        if section_key not in self._sections:
+            raise KeyError(section)
+        return _GitConfigSection(self, self._section_name_map.get(section_key, section_key))
 
-        while True:
-            # We assume to read binary!
-            line = fp.readline().decode(defenc)
-            if not line:
-                break
-            lineno = lineno + 1
-            # Comment or blank line?
-            if line.strip() == "" or self.re_comment.match(line):
-                continue
-            if line.split(None, 1)[0].lower() == "rem" and line[0] in "rR":
-                # No leading whitespace.
-                continue
+    def keys(self) -> List[str]:
+        return self.sections()
 
-            # Is it a section header?
-            mo = self.SECTCRE.match(line.strip())
-            if not is_multi_line and mo:
-                sectname: str = mo.group("header").strip()
-                if sectname in self._sections:
-                    cursect = self._sections[sectname]
-                elif sectname == cp.DEFAULTSECT:
-                    cursect = self._defaults
-                else:
-                    cursect = self._dict((("__name__", sectname),))
-                    self._sections[sectname] = cursect
-                    self._proxies[sectname] = None
-                # So sections can't start with a continuation line.
-                optname = None
-            # No section header in the file?
-            elif cursect is None:
-                raise cp.MissingSectionHeaderError(fpname, lineno, line)
-            # An option line?
-            elif not is_multi_line:
-                mo = self.OPTCRE.match(line)
-                if mo:
-                    # We might just have handled the last line, which could contain a quotation we want to remove.
-                    optname, vi, optval = mo.group("option", "vi", "value")
-                    optname = self.optionxform(optname.rstrip())
-
-                    if vi in ("=", ":") and ";" in optval and not optval.strip().startswith('"'):
-                        pos = optval.find(";")
-                        if pos != -1 and optval[pos - 1].isspace():
-                            optval = optval[:pos]
-                    optval = optval.strip()
-
-                    if len(optval) < 2 or optval[0] != '"':
-                        # Does not open quoting.
-                        pass
-                    elif optval[-1] != '"':
-                        # Opens quoting and does not close: appears to start multi-line quoting.
-                        is_multi_line = True
-                        optval = string_decode(optval[1:])
-                    elif optval.find("\\", 1, -1) == -1 and optval.find('"', 1, -1) == -1:
-                        # Opens and closes quoting. Single line, and all we need is quote removal.
-                        optval = optval[1:-1]
-                    # TODO: Handle other quoted content, especially well-formed backslash escapes.
-
-                    # Preserves multiple values for duplicate optnames.
-                    cursect.add(optname, optval)
-                else:
-                    # Check if it's an option with no value - it's just ignored by git.
-                    if not self.OPTVALUEONLY.match(line):
-                        if not e:
-                            e = cp.ParsingError(fpname)
-                        e.append(lineno, repr(line))
-                    continue
-            else:
-                line = line.rstrip()
-                if line.endswith('"'):
-                    is_multi_line = False
-                    line = line[:-1]
-                # END handle quotations
-                optval = cursect.getlast(optname)
-                cursect.setlast(optname, optval + string_decode(line))
-            # END parse section or option
-        # END while reading
-
-        # If any parsing errors occurred, raise an exception.
-        if e:
-            raise e
+    def values(self) -> List[_GitConfigSection]:
+        return [self[section] for section in self.sections()]
+
+    @staticmethod
+    def _normalize_section_name(section: str) -> str:
+        return _section_name_key(section)
+
+    @needs_values
+    def get(
+        self,
+        section: str,
+        option: str,
+        raw: bool = False,
+        vars: Union[Dict[str, Any], None] = None,
+        fallback: Any = _MISSING,
+    ) -> Any:
+        """Get an option using Git's section and option case rules."""
+        del raw  # Git config values are never interpolated.
+        section_key = self._normalize_section_name(section)
+        if section_key not in self._sections:
+            if fallback is not _MISSING:
+                return fallback
+            raise NoSectionError(section)
+
+        option_key = self.optionxform(option)
+        if vars is not None:
+            for var_name, var_value in vars.items():
+                if self.optionxform(var_name) == option_key:
+                    return var_value
+        section_data = self._sections[section_key]
+        if option_key not in section_data:
+            if fallback is not _MISSING:
+                return fallback
+            raise NoOptionError(option, self._section_name_map.get(section_key, section))
+        value = section_data.getlast(option_key)
+        return "true" if value is None else value
+
+    @needs_values
+    def has_section(self, section: str) -> bool:
+        """Return whether *section* exists, ignoring case in its base name."""
+        section = self._normalize_section_name(section)
+        return section in self._sections
+
+    @needs_values
+    def has_option(self, section: str, option: str) -> bool:
+        """Return whether *option* exists using Git's case rules."""
+        section = self._normalize_section_name(section)
+        return section in self._sections and self.optionxform(option) in self._sections[section]
+
+    @needs_values
+    def options(self, section: str) -> List[str]:
+        """Return option names with their original spelling."""
+        section = self._normalize_section_name(section)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        return [self._option_name_map.get((section, option), option) for option in self._sections[section].options()]
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def remove_option(self, section: str, option: str) -> bool:
+        """Remove an option using Git's section and option case rules."""
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        removed = self._sections[section].remove(option_key)
+        if removed:
+            self._option_name_map.pop((section, option_key), None)
+        return removed
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def remove_section(self, section: str) -> bool:
+        """Remove a section while ignoring case in its base name."""
+        section = self._normalize_section_name(section)
+        removed = section in self._sections
+        if removed:
+            del self._sections[section]
+            self._section_name_map.pop(section, None)
+            for name_key in [name_key for name_key in self._option_name_map if name_key[0] == section]:
+                del self._option_name_map[name_key]
+        return removed
+
+    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
+        """Parse one file according to the grammar implemented by Git itself."""
+        parser = _GitConfigFileParser(fp.read().decode(defenc), fpname)
+        for section, option, value in parser.parse():
+            section_key = _section_name_key(section)
+            if section_key not in self._sections:
+                self._sections[section_key] = _GitConfigSectionData()
+                self._section_name_map[section_key] = section
+            if option is not None:
+                option_key = self.optionxform(option)
+                self._sections[section_key].add(option_key, value)
+                self._option_name_map.setdefault((section_key, option_key), option)
 
     def _has_includes(self) -> Union[bool, int]:
         return self._merge_includes and len(self._included_paths())
@@ -555,17 +777,17 @@ def _included_paths(self) -> List[Tuple[str, str]]:
 
         def _all_items(section: str) -> List[Tuple[str, str]]:
             """Return all (key, value) pairs for a section, including duplicate keys."""
+            section = _section_name_key(section)
             return [
-                (key, value)
+                (key, "true" if value is None else value)
                 for key, values in self._sections[section].items_all()
-                if key != "__name__"
                 for value in values
             ]
 
         paths = []
 
         for section in self.sections():
-            if section == "include":
+            if _section_name_key(section) == "include":
                 paths += _all_items(section)
 
             match = CONDITIONAL_INCLUDE_REGEXP.search(section)
@@ -610,7 +832,7 @@ def _all_items(section: str) -> List[Tuple[str, str]]:
                         break
         return paths
 
-    def read(self) -> None:  # type: ignore[override]
+    def read(self) -> None:
         """Read the data stored in the files we have been initialized with.
 
         This will ignore files that cannot be read, possibly leaving an empty
@@ -686,50 +908,50 @@ def read(self) -> None:  # type: ignore[override]
             self._merge_includes = False
 
     def _write(self, fp: IO) -> None:
-        """Write an .ini-format representation of the configuration state in
-        git compatible format."""
+        """Write a canonical Git-config representation of the configuration state."""
 
-        def write_section(name: str, section_dict: _OMD) -> None:
-            fp.write(("[%s]\n" % name).encode(defenc))
-
-            values: Sequence[str]  # Runtime only gets str in tests, but should be whatever _OMD stores.
-            v: str
-            for key, values in section_dict.items_all():
-                if key == "__name__":
-                    continue
+        def write_section(name: str, section_data: _GitConfigSectionData) -> None:
+            section_name = self._section_name_map.get(name, name)
+            fp.write(("[%s]\n" % _canonical_section_name(section_name)).encode(defenc))
 
-                for v in values:
-                    fp.write(("\t%s = %s\n" % (key, self._value_to_string(v).replace("\n", "\n\t"))).encode(defenc))
-                # END if key is not __name__
+            for key, values in section_data.items_all():
+                for raw_value in values:
+                    option_name = self._option_name_map.get((name, key), key)
+                    if raw_value is None:
+                        fp.write(("\t%s\n" % option_name).encode(defenc))
+                        continue
+                    value = _escape_config_value(self._value_to_string(raw_value))
+                    fp.write(("\t%s = %s\n" % (option_name, value)).encode(defenc))
 
         # END section writing
 
-        if self._defaults:
-            write_section(cp.DEFAULTSECT, self._defaults)
-        value: _OMD
-
-        for name, value in self._sections.items():
-            write_section(name, value)
+        for name, section_data in self._sections.items():
+            write_section(name, section_data)
 
-    def items(self, section_name: str) -> List[Tuple[str, str]]:  # type: ignore[override]
+    @needs_values
+    def items(self, section_name: str) -> List[Tuple[str, str]]:
         """:return: list((option, value), ...) pairs of all items in the given section"""
-        return [(k, v) for k, v in super().items(section_name) if k != "__name__"]
+        section_name = self._normalize_section_name(section_name)
+        if section_name not in self._sections:
+            raise NoSectionError(section_name)
+        return [
+            (self._option_name_map.get((section_name, key), key), "true" if values[-1] is None else values[-1])
+            for key, values in self._sections[section_name].items_all()
+        ]
 
+    @needs_values
     def items_all(self, section_name: str) -> List[Tuple[str, List[str]]]:
         """:return: list((option, [values...]), ...) pairs of all items in the given section"""
-        rv = _OMD(self._defaults)
-
-        for k, vs in self._sections[section_name].items_all():
-            if k == "__name__":
-                continue
-
-            if k in rv and rv.getall(k) == vs:
-                continue
-
-            for v in vs:
-                rv.add(k, v)
-
-        return rv.items_all()
+        section_name = self._normalize_section_name(section_name)
+        if section_name not in self._sections:
+            raise NoSectionError(section_name)
+        return [
+            (
+                self._option_name_map.get((section_name, key), key),
+                ["true" if value is None else value for value in values],
+            )
+            for key, values in self._sections[section_name].items_all()
+        ]
 
     @needs_values
     def write(self) -> None:
@@ -781,10 +1003,20 @@ def _assure_writable(self, method_name: str) -> None:
         if self.read_only:
             raise IOError("Cannot execute non-constant method %s.%s" % (self, method_name))
 
-    def add_section(self, section: "cp._SectionName") -> None:
+    def _add_section(self, section: str) -> None:
+        section_name = _canonical_section_name(section)
+        section_key = _section_name_key(section_name)
+        if section_key in self._sections:
+            raise DuplicateSectionError(section_name)
+        self._sections[section_key] = _GitConfigSectionData()
+        self._section_name_map[section_key] = section_name
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def add_section(self, section: str) -> None:
         """Assures added options will stay in order."""
         self._assure_config_name_safe(section, "section")
-        return super().add_section(section)
+        self._add_section(section)
 
     @property
     def read_only(self) -> bool:
@@ -812,7 +1044,7 @@ def get_value(
 
         :raise TypeError:
             In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
+            Otherwise the parser's lookup exceptions will be raised.
         """
         try:
             valuestr = self.get(section, option)
@@ -843,17 +1075,75 @@ def get_values(
 
         :raise TypeError:
             In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
+            Otherwise the parser's lookup exceptions will be raised.
         """
         try:
             self.sections()
-            lst = self._sections[section].getall(option)
+            section = self._normalize_section_name(section)
+            lst = self._sections[section].getall(self.optionxform(option))
         except Exception:
             if default is not None:
                 return [default]
             raise
 
-        return [self._string_to_value(valuestr) for valuestr in lst]
+        return [True if valuestr is None else self._string_to_value(valuestr) for valuestr in lst]
+
+    def _get_with_fallback(self, section: str, option: str, fallback: Any) -> Any:
+        if fallback is _MISSING:
+            return self.get(section, option)
+        return self.get(section, option, fallback=fallback)
+
+    def getint(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return an integer parsed with Git's base prefixes and binary suffixes."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        match = re.fullmatch(r"([+-]?)(0[xX][0-9a-fA-F]+|0[0-7]*|[1-9][0-9]*)([kKmMgG]?)", value)
+        if match is None:
+            raise ValueError("Not a valid Git integer: %r" % value)
+        sign, number, suffix = match.groups()
+        if number.lower().startswith("0x"):
+            base = 16
+        elif len(number) > 1 and number.startswith("0"):
+            base = 8
+        else:
+            base = 10
+        factor = {"": 1, "k": 1024, "m": 1024**2, "g": 1024**3}[suffix.lower()]
+        parsed = int(number, base) * factor
+        return -parsed if sign == "-" else parsed
+
+    def getfloat(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return a floating-point value parsed with Git's binary suffixes."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        match = re.fullmatch(
+            r"([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)([kKmMgG]?)",
+            value,
+        )
+        if match is None:
+            raise ValueError("Not a valid Git floating-point value: %r" % value)
+        number, suffix = match.groups()
+        factor = {"": 1, "k": 1024, "m": 1024**2, "g": 1024**3}[suffix.lower()]
+        return float(number) * factor
+
+    def getboolean(self, section: str, option: str, fallback: Any = _MISSING, **kwargs: Any) -> Any:
+        """Return a boolean using Git's spelling and numeric rules."""
+        del kwargs
+        value = self._get_with_fallback(section, option, fallback)
+        if value is fallback and fallback is not _MISSING:
+            return fallback
+        normalized = value.lower()
+        if normalized in ("true", "yes", "on"):
+            return True
+        if normalized in ("", "false", "no", "off"):
+            return False
+        try:
+            return self.getint(section, option) != 0
+        except ValueError as error:
+            raise ValueError("Not a boolean: %r" % value) from error
 
     def _string_to_value(self, valuestr: str) -> Union[int, float, str, bool]:
         types = (int, float)
@@ -890,29 +1180,25 @@ def _value_to_string(self, value: Union[str, bytes, int, float, bool]) -> str:
 
     def _value_to_string_safe(self, value: Union[str, bytes, int, float, bool]) -> str:
         value_str = self._value_to_string(value)
-        if UNSAFE_CONFIG_CHARS_RE.search(value_str):
-            raise ValueError("Git config values must not contain CR, LF, or NUL")
+        if UNSAFE_CONFIG_VALUE_CHARS_RE.search(value_str):
+            raise ValueError("Git config values must not contain NUL")
         return value_str
 
-    def _assure_config_name_safe(self, name: "cp._SectionName", label: str) -> None:
-        if isinstance(name, str) and UNSAFE_CONFIG_CHARS_RE.search(name):
+    def _assure_config_name_safe(self, name: str, label: str) -> None:
+        if not isinstance(name, str):
+            raise TypeError("Git config %s names must be strings" % label)
+        if UNSAFE_CONFIG_CHARS_RE.search(name):
             raise ValueError("Git config %s names must not contain CR, LF, or NUL" % label)
-        if label == "section" and isinstance(name, str):
-            in_quotes = False
-            escaped = False
-            for index, char in enumerate(name):
-                if escaped:
-                    escaped = False
-                elif in_quotes and char == "\\":
-                    escaped = True
-                elif char == '"':
-                    if not in_quotes and (index == 0 or name[index - 1] not in " \t"):
-                        raise ValueError("Git config quoted subsection names must begin after whitespace")
-                    in_quotes = not in_quotes
-                elif char == "]" and not in_quotes:
-                    raise ValueError("Git config section names must not contain an unquoted closing bracket")
-            if in_quotes:
-                raise ValueError("Git config section names must not contain an unterminated quote")
+        if label == "section":
+            try:
+                _canonical_section_name(name)
+            except ConfigError as error:
+                raise ValueError("Invalid Git config section name: %s" % name) from error
+        elif label == "option":
+            if not name or not (name[0].isascii() and name[0].isalpha()):
+                raise ValueError("Git config option names must start with an ASCII letter")
+            if not all(_GitConfigFileParser._is_key_char(char) for char in name):
+                raise ValueError("Git config option names may contain only ASCII letters, digits, and hyphens")
 
     @needs_values
     @set_dirty_and_flush_changes
@@ -924,9 +1210,14 @@ def set(
     ) -> None:
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
         if value is not None:
             value = self._value_to_string_safe(value)
-        return super().set(section, option, value)
+        if section not in self._sections:
+            raise NoSectionError(section)
+        self._sections[section].set(option_key, value)
+        self._option_name_map.setdefault((section, option_key), option)
 
     @needs_values
     @set_dirty_and_flush_changes
@@ -934,7 +1225,7 @@ def set_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """Set the given option in section to the given value.
 
         This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method.
+        lower-level :meth:`set` method.
 
         :param section:
             Name of the section in which the option resides or should reside.
@@ -950,10 +1241,14 @@ def set_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section_name = _canonical_section_name(section)
+        section = self._normalize_section_name(section)
+        option_key = self.optionxform(option)
         value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
-            self.add_section(section)
-        super().set(section, option, value_str)
+            self._add_section(section_name)
+        self._sections[section].set(option_key, value_str)
+        self._option_name_map.setdefault((section, option_key), option)
         return self
 
     @needs_values
@@ -962,7 +1257,7 @@ def add_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """Add a value for the given option in section.
 
         This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method. The value becomes the new value of the
+        lower-level :meth:`set` method. The value becomes the new value of the
         option as returned by :meth:`get_value`, and appends to the list of values
         returned by :meth:`get_values`.
 
@@ -980,10 +1275,15 @@ def add_value(self, section: str, option: str, value: Union[str, bytes, int, flo
         """
         self._assure_config_name_safe(section, "section")
         self._assure_config_name_safe(option, "option")
+        section_name = _canonical_section_name(section)
+        section = self._normalize_section_name(section)
+        option_name = option
+        option = self.optionxform(option_name)
         value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
-            self.add_section(section)
+            self.add_section(section_name)
         self._sections[section].add(option, value_str)
+        self._option_name_map.setdefault((section, option), option_name)
         return self
 
     def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
@@ -998,16 +1298,21 @@ def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
         :return:
             This instance
         """
+        section = self._normalize_section_name(section)
+        self._assure_config_name_safe(new_name, "section")
+        new_section_name = _canonical_section_name(new_name)
+        new_name = self._normalize_section_name(new_section_name)
         if not self.has_section(section):
             raise ValueError("Source section '%s' doesn't exist" % section)
-        self._assure_config_name_safe(new_name, "section")
         if self.has_section(new_name):
             raise ValueError("Destination section '%s' already exists" % new_name)
 
-        super().add_section(new_name)
+        self._sections[new_name] = _GitConfigSectionData()
+        self._section_name_map[new_name] = new_section_name
         new_section = self._sections[new_name]
-        for k, vs in self.items_all(section):
-            new_section.setall(k, vs)
+        for option_key, values in self._sections[section].items_all():
+            new_section.setall(option_key, values)
+            self._option_name_map[(new_name, option_key)] = self._option_name_map.get((section, option_key), option_key)
         # END for each value to copy
 
         # This call writes back the changes, which is why we don't have the respective
diff --git a/git/objects/submodule/base.py b/git/objects/submodule/base.py
index 7984db340..0e90ec53b 100644
--- a/git/objects/submodule/base.py
+++ b/git/objects/submodule/base.py
@@ -4,6 +4,7 @@
 __all__ = ["Submodule", "UpdateProgress"]
 
 import gc
+from configparser import NoSectionError
 from io import BytesIO
 import logging
 import os
@@ -16,7 +17,7 @@
 import git
 from git.cmd import Git
 from git.compat import defenc
-from git.config import GitConfigParser, SectionConstraint, cp
+from git.config import GitConfigParser, SectionConstraint
 from git.exc import (
     BadName,
     InvalidGitRepositoryError,
@@ -172,7 +173,7 @@ def _set_cache_(self, attr: str) -> None:
             # Default submodule values.
             try:
                 self.path = reader.get("path")
-            except cp.NoSectionError as e:
+            except NoSectionError as e:
                 if self.repo.working_tree_dir is not None:
                     raise ValueError(
                         "This submodule instance does not exist anymore in '%s' file"
@@ -1503,7 +1504,7 @@ def exists(self) -> bool:
                 if hasattr(self, attr):
                     loc[attr] = getattr(self, attr)
                 # END if we have the attribute cache
-            except (cp.NoSectionError, ValueError):
+            except (NoSectionError, ValueError):
                 # On PY3, this can happen apparently... don't know why this doesn't
                 # happen on PY2.
                 pass
diff --git a/git/objects/submodule/util.py b/git/objects/submodule/util.py
index c021510d8..50c3fdb89 100644
--- a/git/objects/submodule/util.py
+++ b/git/objects/submodule/util.py
@@ -110,7 +110,7 @@ def flush_to_index(self) -> None:
     # } END interface
 
     # { Overridden Methods
-    def write(self) -> None:  # type: ignore[override]
+    def write(self) -> None:
         rval: None = super().write()
         self.flush_to_index()
         return rval
diff --git a/git/remote.py b/git/remote.py
index 0c3dbfe15..79850ab11 100644
--- a/git/remote.py
+++ b/git/remote.py
@@ -8,12 +8,13 @@
 __all__ = ["RemoteProgress", "PushInfo", "FetchInfo", "Remote"]
 
 import contextlib
+from configparser import NoOptionError, NoSectionError
 import logging
 import re
 
 from git.cmd import Git, handle_process_output
 from git.compat import defenc, force_text
-from git.config import GitConfigParser, SectionConstraint, cp
+from git.config import GitConfigParser, SectionConstraint
 from git.exc import GitCommandError
 from git.refs import Head, Reference, RemoteReference, SymbolicReference, TagReference
 from git.util import (
@@ -577,7 +578,7 @@ def __getattr__(self, attr: str) -> Any:
         # though a slot of the same name exists.
         try:
             return self._config_reader.get(attr)
-        except cp.NoOptionError:
+        except NoOptionError:
             return super().__getattr__(attr)
         # END handle exception
 
@@ -619,10 +620,10 @@ def exists(self) -> bool:
         try:
             self.config_reader.get("url")
             return True
-        except cp.NoOptionError:
+        except NoOptionError:
             # We have the section at least...
             return True
-        except cp.NoSectionError:
+        except NoSectionError:
             return False
 
     @classmethod
diff --git a/test/fixtures/git_config b/test/fixtures/git_config
index a8cad56e8..904946288 100644
--- a/test/fixtures/git_config
+++ b/test/fixtures/git_config
@@ -22,8 +22,7 @@
 	url = git://gitorious.org/~martin.marcher/git-python/serverhorror.git
 	fetch = +refs/heads/*:refs/remotes/MartinMarcher/*
     # can handle comments - the section name is supposed to be stripped
-# causes stock git-config puke
-[  gui ]
+[gui]
 	geometry = 1316x820+219+243 207 192
 [branch "mainline_performance"]
 	remote = mainline
@@ -43,4 +42,3 @@
 # inclusions should be processed immediately
 [sec]
     var1 = value1_main
-
diff --git a/test/fixtures/git_config_multiple b/test/fixtures/git_config_multiple
index 03a975680..0c5c71ca2 100644
--- a/test/fixtures/git_config_multiple
+++ b/test/fixtures/git_config_multiple
@@ -4,4 +4,4 @@
 [section1]
     option1 = value1a
     option1 = value1b
-    other_option1 = other_value1
+    other-option1 = other_value1
diff --git a/test/fixtures/git_config_with_quotes_escapes b/test/fixtures/git_config_with_quotes_escapes
index 33332c221..c67c68bc7 100644
--- a/test/fixtures/git_config_with_quotes_escapes
+++ b/test/fixtures/git_config_with_quotes_escapes
@@ -3,7 +3,5 @@
   hasbackslash = "foo\\bar"
   hasquote = "ab\"cd"
   hastrailingbackslash = "word\\"
-  hasunrecognized = "p\qrs"
-  hasunescapedquotes = "ab"cd"e"
   ordinary = "hello world"
   unquoted = good evening
diff --git a/test/test_config.py b/test/test_config.py
index 361a51fa9..279f6b454 100644
--- a/test/test_config.py
+++ b/test/test_config.py
@@ -4,6 +4,7 @@
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
 import glob
+import configparser as cp
 import io
 import os
 import os.path as osp
@@ -12,8 +13,8 @@
 
 import pytest
 
-from git import GitConfigParser
-from git.config import _OMD, cp
+from git import Git, GitConfigParser
+from git.config import _escape_config_value, _escape_section_subsection
 from git.util import rmfile
 
 from test.lib import SkipTest, TestCase, fixture_path, with_rw_directory
@@ -66,7 +67,7 @@ def test_read_write(self):
                 assert w_config._lock._has_lock()
 
                 # Changes should be written right away.
-                sname = "my_section"
+                sname = "my-section"
                 oname = "mykey"
                 val = "myvalue"
                 w_config.add_section(sname)
@@ -75,8 +76,8 @@ def test_read_write(self):
                 assert w_config.has_option(sname, oname)
                 assert w_config.get(sname, oname) == val
 
-                sname_new = "new_section"
-                oname_new = "new_key"
+                sname_new = "new-section"
+                oname_new = "new-key"
                 ival = 10
                 w_config.set_value(sname_new, oname_new, ival)
                 assert w_config.get_value(sname_new, oname_new) == ival
@@ -107,10 +108,10 @@ def test_lock_reentry(self, rw_dir):
         fpl = osp.join(rw_dir, "l")
         gcp = GitConfigParser(fpl, read_only=False)
         with gcp as cw:
-            cw.set_value("include", "some_value", "a")
+            cw.set_value("include", "some-value", "a")
         # Entering again locks the file again...
         with gcp as cw:
-            cw.set_value("include", "some_other_value", "b")
+            cw.set_value("include", "some-other-value", "b")
             # ...so creating an additional config writer must fail due to exclusive
             # access.
             with self.assertRaises(IOError):
@@ -142,25 +143,160 @@ def test_multi_line_config(self):
             )
             self.assertEqual(len(config.sections()), 23)
 
-    def test_config_value_with_trailing_new_line(self):
+    def test_config_rejects_colon_delimiter_and_unterminated_quote(self):
         config_content = b'[section-header]\nkey:"value\n"'
         config_file = io.BytesIO(config_content)
         config_file.name = "multiline_value.config"
 
         git_config = GitConfigParser(config_file)
-        git_config.read()  # This should not throw an exception
+        with pytest.raises(cp.ParsingError):
+            git_config.read()
+
+    def test_git_parser_handles_stream_syntax_comments_and_continuations(self):
+        config_file = io.BytesIO(
+            b"\xef\xbb\xbf; comment\r\n[Core] [other]\r\nenabled\r\npath = one\\\r\n two # trailing comment\r\n"
+        )
+        config_file.name = "git-syntax.config"
+
+        git_config = GitConfigParser(config_file)
+        self.assertEqual(git_config.sections(), ["Core", "other"])
+        self.assertTrue(git_config.has_section("CORE"))
+        self.assertIs(git_config.get_value("other", "enabled"), True)
+        self.assertEqual(git_config.get_value("other", "path"), "one two")
+
+    @with_rw_directory
+    def test_section_and_option_case_match_git(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with open(config_path, "wb") as config_file:
+            config_file.write(b'[CoRe]\n\tMixedOption = "one"\n[Remote "Origin"]\n\tFetchURL = "example"\n')
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.set_value("CORE", "MIXEDOPTION", "two")
+            git_config.set_value("core", "NewOption", "new")
+
+            self.assertEqual(git_config.sections(), ["CoRe", 'Remote "Origin"'])
+            self.assertEqual(git_config.get_value("cOrE", "mixedOPTION"), "two")
+            self.assertEqual(git_config.get_values("CORE", "MixedOption"), ["two"])
+            self.assertEqual(git_config.options("CORE"), ["MixedOption", "NewOption"])
+            self.assertEqual(git_config.items("CORE"), [("MixedOption", "two"), ("NewOption", "new")])
+            self.assertEqual(git_config.items_all("CORE"), [("MixedOption", ["two"]), ("NewOption", ["new"])])
+            core = git_config["CORE"]
+            self.assertEqual(core.name, "CoRe")
+            self.assertEqual(list(core), ["MixedOption", "NewOption"])
+            self.assertEqual(list(core.items()), [("MixedOption", "two"), ("NewOption", "new")])
+            self.assertEqual(core["MixedOption"], "two")
+            self.assertEqual(list(git_config), ["CoRe", 'Remote "Origin"'])
+            self.assertTrue(git_config.has_option("CORE", "MixedOption"))
+            self.assertTrue(git_config.has_section('REMOTE "Origin"'))
+            self.assertFalse(git_config.has_section('remote "origin"'))
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[CoRe]\n\tMixedOption = "two"\n\tNewOption = "new"\n[Remote "Origin"]\n\tFetchURL = "example"\n',
+            )
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.rename_section('REMOTE "Origin"', 'Branch "Origin"')
+            self.assertEqual(git_config.get_value('BRANCH "Origin"', "fetchurl"), "example")
+            self.assertEqual(git_config.sections(), ["CoRe", 'Branch "Origin"'])
+            self.assertEqual(git_config.options('branch "Origin"'), ["FetchURL"])
+            self.assertEqual(git_config['branch "Origin"'].name, 'Branch "Origin"')
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[CoRe]\n\tMixedOption = "two"\n\tNewOption = "new"\n[Branch "Origin"]\n\tFetchURL = "example"\n',
+            )
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.get_value("CORE", "MIXEDOPTION"), "two")
+            self.assertEqual(git_config.get_value('branch "Origin"', "FETCHURL"), "example")
+
+    def test_git_parser_rejects_syntax_rejected_by_git(self):
+        invalid_configs = (
+            b"[  gui]\nkey = value\n",
+            b"[core]\nbad_key = value\n",
+            b"[core]\nkey: value\n",
+            b'[core]\nkey = "unterminated\n',
+            b'[core]\nkey = "bad\\q"\n',
+            b'[core]\nkey = "bad\x00value"\n',
+        )
+        for config_content in invalid_configs:
+            with self.subTest(config_content=config_content):
+                config_file = io.BytesIO(config_content)
+                config_file.name = "invalid-git-syntax.config"
+
+                with pytest.raises(cp.ParsingError):
+                    GitConfigParser(config_file).read()
+
+    @with_rw_directory
+    def test_git_parser_and_canonical_writer_round_trip(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        section = 'submodule "docs]archive"'
+        value = ' leading #; "quoted" \\ tail\nsecond\tcolumn\b'
+        with open(config_path, "wb") as config_file:
+            config_file.write(
+                b'[submodule "docs]archive"]\npayload = " leading #; \\"quoted\\" \\\\ tail\\nsecond\\tcolumn\\b"\n'
+            )
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            self.assertEqual(git_config.get_value(section, "payload"), value)
+            git_config.set_value(section, "other", "x#;y")
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.get_value(section, "payload"), value)
+            self.assertEqual(git_config.get_value(section, "other"), "x#;y")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[submodule "docs]archive"]\n'
+                b'\tpayload = " leading #; \\"quoted\\" \\\\ tail\\nsecond\\tcolumn\\b"\n'
+                b'\tother = "x#;y"\n',
+            )
+
+        self.assertEqual(Git().config("--file", config_path, "--get", "submodule.docs]archive.payload"), value)
+
+    @with_rw_directory
+    def test_writer_rejects_names_outside_git_grammar(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.add_section("core")
+            for option in ("bad_option", "-bad", "bad.option"):
+                with self.subTest(option=option), pytest.raises(ValueError, match="option names"):
+                    git_config.set_value("core", option, "value")
+
+            for section in (" gui", "user trailing", "user] [other"):
+                with self.subTest(section=section), pytest.raises(ValueError, match="section name"):
+                    git_config.add_section(section)
 
     @with_rw_directory
-    def test_set_value_rejects_config_injection(self, rw_dir):
+    def test_writer_escapes_quoted_subsection_names(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        section = 'submodule "docs\\"archive\\\\part]"'
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            git_config.set_value(section, "path", "docs")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(config_file.read(), b'[submodule "docs\\"archive\\\\part]"]\n\tpath = "docs"\n')
+
+        with GitConfigParser(config_path, read_only=True) as git_config:
+            self.assertEqual(git_config.sections(), [section])
+            self.assertEqual(git_config.get_value(section, "path"), "docs")
+
+        self.assertEqual(Git().config("--file", config_path, "--get", 'submodule.docs"archive\\part].path'), "docs")
+
+    @with_rw_directory
+    def test_set_value_escapes_config_injection(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
         payload = "foo\n[core]\nhooksPath=/tmp/hooks"
 
         with GitConfigParser(config_path, read_only=False) as git_config:
-            with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                git_config.set_value("user", "name", payload)
+            git_config.set_value("user", "name", payload)
 
         with GitConfigParser(config_path, read_only=True) as git_config:
-            self.assertFalse(git_config.has_section("user"))
+            self.assertEqual(git_config.get_value("user", "name"), payload)
             self.assertFalse(git_config.has_section("core"))
 
     @with_rw_directory
@@ -197,13 +333,7 @@ def test_set_value_rejects_unsafe_section_and_option_names(self, rw_dir):
     @with_rw_directory
     def test_writer_rejects_unquoted_section_terminators(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
-        bad_sections = (
-            "user] [other",
-            'user"] [other"',
-            'submodule "docs"] [other',
-            'submodule "docs] [other',
-            'submodule "docs] [other\\',
-        )
+        bad_sections = ("user] [other", 'submodule "docs"] [other')
         safe_section = 'submodule "docs]archive"'
 
         with GitConfigParser(config_path, read_only=False) as git_config:
@@ -242,24 +372,26 @@ def test_writer_rejects_unquoted_section_terminators(self, rw_dir):
             self.assertFalse(git_config.has_section("other"), "an unsafe section name injected an [other] section")
 
     @with_rw_directory
-    def test_set_and_add_value_reject_unsafe_value_characters(self, rw_dir):
+    def test_set_and_add_value_match_git_control_character_handling(self, rw_dir):
         config_path = osp.join(rw_dir, "config")
-        bad_values = ("foo\rbar", "foo\nbar", "foo\x00bar", b"foo\nbar")
 
         with GitConfigParser(config_path, read_only=False) as git_config:
             git_config.add_section("user")
-            for bad_value in bad_values:
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.set("user", "name", bad_value)
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.set_value("user", "name", bad_value)
-                with pytest.raises(ValueError, match="CR, LF, or NUL"):
-                    git_config.add_value("user", "name", bad_value)
+            git_config.set("user", "carriage-return", "foo\rbar")
+            git_config.set_value("user", "line-feed", "foo\nbar")
+            git_config.add_value("user", "bytes-line-feed", b"foo\nbar")
 
-            git_config.set_value("user", "name", "safe")
+            for setter in (git_config.set, git_config.set_value, git_config.add_value):
+                with pytest.raises(ValueError, match="must not contain NUL"):
+                    setter("user", "name", "foo\x00bar")
 
         with GitConfigParser(config_path, read_only=True) as git_config:
-            self.assertEqual(git_config.get_value("user", "name"), "safe")
+            self.assertEqual(git_config.get_value("user", "carriage-return"), "foo\rbar")
+            self.assertEqual(git_config.get_value("user", "line-feed"), "foo\nbar")
+            self.assertEqual(git_config.get_value("user", "bytes-line-feed"), "foo\nbar")
+
+        self.assertEqual(Git().config("--file", config_path, "--get", "user.carriage-return"), "foo\rbar")
+        self.assertEqual(Git().config("--file", config_path, "--get", "user.line-feed"), "foo\nbar")
 
     def test_base(self):
         path_repo = fixture_path("git_config")
@@ -317,19 +449,19 @@ def check_test_value(cr, value):
 
             fpb = osp.join(rw_dir, "b")
             fpc = osp.join(rw_dir, "c")
-            cw.set_value("include", "relative_path_b", "b")
+            cw.set_value("include", "relative-path-b", "b")
             cw.set_value("include", "doesntexist", "foobar")
-            cw.set_value("include", "relative_cycle_a_a", "a")
-            cw.set_value("include", "absolute_cycle_a_a", fpa)
+            cw.set_value("include", "relative-cycle-a-a", "a")
+            cw.set_value("include", "absolute-cycle-a-a", fpa)
         assert osp.exists(fpa)
 
         # PREPARE CONFIG FILE B
         with GitConfigParser(fpb, read_only=False) as cw:
             write_test_value(cw, "b")
-            cw.set_value("include", "relative_cycle_b_a", "a")
-            cw.set_value("include", "absolute_cycle_b_a", fpa)
-            cw.set_value("include", "relative_path_c", "c")
-            cw.set_value("include", "absolute_path_c", fpc)
+            cw.set_value("include", "relative-cycle-b-a", "a")
+            cw.set_value("include", "absolute-cycle-b-a", fpa)
+            cw.set_value("include", "relative-path-c", "c")
+            cw.set_value("include", "absolute-path-c", fpc)
 
         # PREPARE CONFIG FILE C
         with GitConfigParser(fpc, read_only=False) as cw:
@@ -385,8 +517,8 @@ def test_multiple_include_paths_with_same_key(self, rw_dir):
                 path = file1
                 path = file2
 
-        Previously only one of these was included because _OMD.items() returns
-        only the last value for each key.
+        Previously only one of these was included because the old INI-backed storage
+        exposed only the last value for each key.
         """
         # Create two config files to be included.
         fp_inc1 = osp.join(rw_dir, "inc1.cfg")
@@ -403,8 +535,8 @@ def test_multiple_include_paths_with_same_key(self, rw_dir):
         # We write it manually because set_value would overwrite the key.
         with open(fp_main, "w") as f:
             f.write("[include]\n")
-            f.write(f"\tpath = {fp_inc1}\n")
-            f.write(f"\tpath = {fp_inc2}\n")
+            f.write(f"\tpath = {_escape_config_value(fp_inc1)}\n")
+            f.write(f"\tpath = {_escape_config_value(fp_inc2)}\n")
 
         with GitConfigParser(fp_main, read_only=True) as cr:
             # Both included files should be loaded.
@@ -430,8 +562,15 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
         path2 = osp.join(rw_dir, "config2")
         template = '[includeIf "{}:{}"]\n    path={}\n'
 
+        def include_config(condition, pattern):
+            return template.format(
+                condition,
+                _escape_section_subsection(pattern),
+                _escape_config_value(path2),
+            )
+
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir, path2))
+            stream.write(include_config("gitdir", git_dir))
 
         # Ensure that config is ignored if no repo is set.
         with GitConfigParser(path1) as config:
@@ -445,7 +584,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is ignored if case is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", git_dir.upper(), path2))
+            stream.write(include_config("gitdir", git_dir.upper()))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -453,7 +592,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included if case is ignored.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir/i", git_dir.upper(), path2))
+            stream.write(include_config("gitdir/i", git_dir.upper()))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -461,7 +600,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included with path using glob pattern.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "**/repo1", path2))
+            stream.write(include_config("gitdir", "**/repo1"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -469,7 +608,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is ignored if path is not matching git_dir.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "incorrect", path2))
+            stream.write(include_config("gitdir", "incorrect"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -477,7 +616,7 @@ def test_conditional_includes_from_git_dir(self, rw_dir):
 
         # Ensure that config is included if path in hierarchy.
         with open(path1, "w") as stream:
-            stream.write(template.format("gitdir", "target1/", path2))
+            stream.write(include_config("gitdir", "target1/"))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -499,7 +638,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included is branch is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("/foo/branch", path2))
+            stream.write(template.format("/foo/branch", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -507,7 +646,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included is branch is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("incorrect", path2))
+            stream.write(template.format("incorrect", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -515,7 +654,7 @@ def test_conditional_includes_from_branch_name(self, rw_dir):
 
         # Ensure that config is included with branch using glob pattern.
         with open(path1, "w") as stream:
-            stream.write(template.format("/foo/**", path2))
+            stream.write(template.format("/foo/**", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -551,7 +690,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and full url is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("https://github.com/foo/repo", path2))
+            stream.write(template.format("https://github.com/foo/repo", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -559,7 +698,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and incorrect url is incorrect.
         with open(path1, "w") as stream:
-            stream.write(template.format("incorrect", path2))
+            stream.write(template.format("incorrect", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert not config._has_includes()
@@ -567,7 +706,7 @@ def test_conditional_includes_remote_url(self, rw_dir):
 
         # Ensure that config with hasconfig and url using glob pattern is correct.
         with open(path1, "w") as stream:
-            stream.write(template.format("**/**github.com*/**", path2))
+            stream.write(template.format("**/**github.com*/**", _escape_config_value(path2)))
 
         with GitConfigParser(path1, repo=repo) as config:
             assert config._has_includes()
@@ -607,8 +746,7 @@ def test_empty_config_value(self):
 
         assert cr.get_value("core", "filemode"), "Should read keys with values"
 
-        with self.assertRaises(cp.NoOptionError):
-            cr.get_value("color", "ui")
+        self.assertIs(cr.get_value("color", "ui"), True, "a valueless Git config entry means boolean true")
 
     def test_config_with_quotes(self):
         cr = GitConfigParser(fixture_path("git_config_with_quotes"), read_only=True)
@@ -629,18 +767,13 @@ def test_config_with_quotes_with_whitespace_outside_value(self):
         self.assertEqual(cr.get("init", "defaultBranch"), "trunk")
 
     def test_config_with_quotes_containing_escapes(self):
-        """For now just suppress quote removal. But it would be good to interpret most of these."""
+        """Interpret the quoted-value escapes supported by Git."""
         cr = GitConfigParser(fixture_path("git_config_with_quotes_escapes"), read_only=True)
 
-        # These can eventually be supported by substituting the represented character.
-        self.assertEqual(cr.get("custom", "hasnewline"), R'"first\nsecond"')
-        self.assertEqual(cr.get("custom", "hasbackslash"), R'"foo\\bar"')
-        self.assertEqual(cr.get("custom", "hasquote"), R'"ab\"cd"')
-        self.assertEqual(cr.get("custom", "hastrailingbackslash"), R'"word\\"')
-        self.assertEqual(cr.get("custom", "hasunrecognized"), R'"p\qrs"')
-
-        # It is less obvious whether and what to eventually do with this.
-        self.assertEqual(cr.get("custom", "hasunescapedquotes"), '"ab"cd"e"')
+        self.assertEqual(cr.get("custom", "hasnewline"), "first\nsecond")
+        self.assertEqual(cr.get("custom", "hasbackslash"), R"foo\bar")
+        self.assertEqual(cr.get("custom", "hasquote"), 'ab"cd')
+        self.assertEqual(cr.get("custom", "hastrailingbackslash"), "word\\")
 
         # Cases where quote removal is clearly safe should happen even after those.
         self.assertEqual(cr.get("custom", "ordinary"), "hello world")
@@ -657,7 +790,7 @@ def test_get_values_works_without_requiring_any_other_calls_first(self):
         self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b"])
         file_obj.seek(0)
         cr = GitConfigParser(file_obj, read_only=True)
-        self.assertEqual(cr.get_values("section1", "other_option1"), ["other_value1"])
+        self.assertEqual(cr.get_values("section1", "other-option1"), ["other_value1"])
 
     def test_multiple_values(self):
         file_obj = self._to_memcache(fixture_path("git_config_multiple"))
@@ -671,13 +804,13 @@ def test_multiple_values(self):
             self.assertEqual(cw.get_values("section1", "option1"), ["value1a", "value1b"])
             self.assertEqual(
                 cw.items("section1"),
-                [("option1", "value1b"), ("other_option1", "other_value1")],
+                [("option1", "value1b"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cw.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
             with self.assertRaises(KeyError):
@@ -697,13 +830,13 @@ def test_multiple_values_rename(self):
             self.assertEqual(cr.get_values("section2", "option1"), ["value1a", "value1b"])
             self.assertEqual(
                 cr.items("section2"),
-                [("option1", "value1b"), ("other_option1", "other_value1")],
+                [("option1", "value1b"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section2"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
 
@@ -719,37 +852,37 @@ def test_multiple_to_single(self):
             self.assertEqual(cr.get_values("section1", "option1"), ["value1c"])
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1c"), ("other_option1", "other_value1")],
+                [("option1", "value1c"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
-                [("option1", ["value1c"]), ("other_option1", ["other_value1"])],
+                [("option1", ["value1c"]), ("other-option1", ["other_value1"])],
             )
 
     def test_single_to_multiple(self):
         file_obj = self._to_memcache(fixture_path("git_config_multiple"))
         with GitConfigParser(file_obj, read_only=False) as cw:
-            cw.add_value("section1", "other_option1", "other_value1a")
+            cw.add_value("section1", "other-option1", "other_value1a")
 
             cw.write()
             file_obj.seek(0)
             cr = GitConfigParser(file_obj, read_only=True)
             self.assertEqual(cr.get_value("section1", "option1"), "value1b")
             self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b"])
-            self.assertEqual(cr.get_value("section1", "other_option1"), "other_value1a")
+            self.assertEqual(cr.get_value("section1", "other-option1"), "other_value1a")
             self.assertEqual(
-                cr.get_values("section1", "other_option1"),
+                cr.get_values("section1", "other-option1"),
                 ["other_value1", "other_value1a"],
             )
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1b"), ("other_option1", "other_value1a")],
+                [("option1", "value1b"), ("other-option1", "other_value1a")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b"]),
-                    ("other_option1", ["other_value1", "other_value1a"]),
+                    ("other-option1", ["other_value1", "other_value1a"]),
                 ],
             )
 
@@ -764,22 +897,43 @@ def test_add_to_multiple(self):
             self.assertEqual(cr.get_values("section1", "option1"), ["value1a", "value1b", "value1c"])
             self.assertEqual(
                 cr.items("section1"),
-                [("option1", "value1c"), ("other_option1", "other_value1")],
+                [("option1", "value1c"), ("other-option1", "other_value1")],
             )
             self.assertEqual(
                 cr.items_all("section1"),
                 [
                     ("option1", ["value1a", "value1b", "value1c"]),
-                    ("other_option1", ["other_value1"]),
+                    ("other-option1", ["other_value1"]),
                 ],
             )
 
-    def test_setlast(self):
-        # Test directly, not covered by higher-level tests.
-        omd = _OMD()
-        omd.setlast("key", "value1")
-        self.assertEqual(omd["key"], "value1")
-        self.assertEqual(omd.getall("key"), ["value1"])
-        omd.setlast("key", "value2")
-        self.assertEqual(omd["key"], "value2")
-        self.assertEqual(omd.getall("key"), ["value2"])
+    def test_parser_uses_git_native_storage(self):
+        self.assertFalse(issubclass(GitConfigParser, cp.RawConfigParser))
+
+    @with_rw_directory
+    def test_valueless_entries_remain_distinct_from_literal_true(self, rw_dir):
+        config_path = osp.join(rw_dir, "config")
+        with open(config_path, "wb") as config_file:
+            config_file.write(b'[Feature]\n\tImplicit\n\tExplicit = "true"\n')
+
+        with GitConfigParser(config_path, read_only=False) as git_config:
+            self.assertIs(git_config.get_value("feature", "implicit"), True)
+            self.assertIs(git_config.get_value("FEATURE", "EXPLICIT"), True)
+            git_config.set_value("feature", "Other", "value")
+
+        with open(config_path, "rb") as config_file:
+            self.assertEqual(
+                config_file.read(),
+                b'[Feature]\n\tImplicit\n\tExplicit = "true"\n\tOther = "value"\n',
+            )
+
+    def test_git_typed_accessors(self):
+        config_file = io.BytesIO(b"[values]\nsize = 2k\nratio = 1.5m\nyes = on\nno = 0\nimplicit\n")
+        config_file.name = "typed-values.config"
+        git_config = GitConfigParser(config_file)
+
+        self.assertEqual(git_config.getint("VALUES", "SIZE"), 2048)
+        self.assertEqual(git_config.getfloat("values", "ratio"), 1.5 * 1024**2)
+        self.assertIs(git_config.getboolean("values", "yes"), True)
+        self.assertIs(git_config.getboolean("values", "no"), False)
+        self.assertIs(git_config.getboolean("values", "implicit"), True)
diff --git a/test/test_submodule.py b/test/test_submodule.py
index 265ee2ffb..6922b0da6 100644
--- a/test/test_submodule.py
+++ b/test/test_submodule.py
@@ -2,6 +2,7 @@
 # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
 
 import contextlib
+import configparser as cp
 import gc
 import os
 import os.path as osp
@@ -15,7 +16,7 @@
 
 import git
 from git.cmd import Git
-from git.config import GitConfigParser, cp
+from git.config import GitConfigParser
 from git.exc import (
     GitCommandError,
     InvalidGitRepositoryError,
@@ -987,10 +988,10 @@ def test_git_submodules_and_add_sm_with_new_commit(self, rwdir):
 
         parent.index.commit("moved submodules")
 
-        with sm.config_writer() as writer:
-            writer.set_value("user.email", "example@example.com")
-            writer.set_value("user.name", "me")
         smm = sm.module()
+        with smm.config_writer() as writer:
+            writer.set_value("user", "email", "example@example.com")
+            writer.set_value("user", "name", "me")
         fp = osp.join(smm.working_tree_dir, "empty-file")
         with open(fp, "w"):
             pass