fix(config): decode escapes in unquoted config values

Git decodes the standard escape sequences in unquoted config values, but
`GitConfigParser._read` only called `parse_value()` when a value continued
onto a following line. A single-line unquoted value therefore kept its
escapes literal, so `b = first\nsecond` read back as `first\nsecond`
rather than `first<LF>second`.

The same value also decoded differently depending only on whether it was
wrapped: `b = first\nsecond \` continued onto a second line already went
through `parse_value()` and was decoded.

The missing decode made writes unsafe. The parsed value held no control
character, so the writer's CR/LF/NUL guard did not trigger, and saving an
unrelated key emitted a value that git then read differently than before.
With the escape decoded, the existing guard rejects the value instead of
corrupting the file.

A value is decoded only when every backslash in it introduces a known
escape. Git rejects an unknown escape outright, so GitPython never had to
handle one; it tolerates them instead, which is what keeps a Windows path
such as `C:\Users\me` usable. Decoding unconditionally would have broken
that: the `\t` of `\Temp\test_foo` would become a tab while the `\U` of
`\Users` stayed literal, mangling the path. Guarding on the whole value
decodes `a\tb` and `foo\\bar` as git does and leaves the path alone.

An existing case in `test_backslash_line_continuation` asserted the
undecoded spelling `val\\` for `k = val\\` followed by a newline. Git
yields `val\` there, since the second backslash escapes the first, so
that expectation is corrected to match.

Checked against git 2.50.1 (Apple Git-155).

Co-Authored-By: Codex <codex@openai.com>

Author: JingHao-Leon

git/config.py

@@ -69,6 +69,13 @@
 VALID_CONFIG_OPTION_NAME_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
 """Pattern for option names that can be written without changing config syntax."""
 
+UNQUOTED_ESCAPES = {"b": "\b", "n": "\n", "t": "\t", '"': '"', "\\": "\\"}
+"""Escape sequences git recognizes in an unquoted value.
+
+Any other backslash escape is an error for git, which is why a value holding one is
+left undecoded rather than rejected.
+"""
+
 
 class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
     """Utility class wrapping base-class methods into decorators that assure read-only
@@ -530,10 +537,9 @@ def parse_value(value: str) -> str:
             parsed: List[str] = []
             whitespace: List[str] = []
             quoted = escaped = False
-            escapes = {"b": "\b", "n": "\n", "t": "\t", '"': '"', "\\": "\\"}
             for char in value:
                 if escaped:
-                    parsed.append(escapes.get(char, "\\" + char))
+                    parsed.append(UNQUOTED_ESCAPES.get(char, "\\" + char))
                     escaped = False
                     continue
                 if char.isspace() and not quoted:
@@ -552,6 +558,26 @@ def parse_value(value: str) -> str:
                     parsed.append(char)
             return "".join(parsed)
 
+        def escapes_are_known(value: str) -> bool:
+            """Whether every backslash in `value` introduces an escape git recognises.
+
+            Git rejects an unquoted value carrying an unknown escape outright. GitPython
+            tolerates such values, because that is what lets a Windows path such as
+            ``C:\\Users\\me`` stay literal, so a value is decoded only when every one
+            of its backslashes is part of a known escape. Decoding part of a value would
+            otherwise turn the ``\\t`` of ``\\Temp\\test`` into a tab while leaving the
+            ``\\U`` of ``\\Users`` alone.
+            """
+            index = value.find("\\")
+            while index >= 0:
+                # A trailing backslash has nothing to escape and git drops it, so
+                # only a backslash followed by an unknown escape disqualifies the
+                # value from being decoded.
+                if index + 1 < len(value) and value[index + 1] not in UNQUOTED_ESCAPES:
+                    return False
+                index = value.find("\\", index + 2)
+            return True
+
         while True:
             # We assume to read binary!
             raw_line = fp.readline()
@@ -606,7 +632,6 @@ def parse_value(value: str) -> str:
                         # next line is appended before the complete value is
                         # parsed. An even number means the last backslash is
                         # escaped and the value ends there.
-                        continued = False
                         while True:
                             if not is_line_continuation(optval):
                                 break
@@ -620,8 +645,11 @@ def parse_value(value: str) -> str:
                             while joined.endswith("\n") or joined.endswith("\r"):
                                 joined = joined[:-1]
                             optval = optval[:-1] + joined
-                            continued = True
-                        if continued:
+                        # Git decodes the standard escape sequences in unquoted
+                        # values, but only a value in which every backslash is part
+                        # of a known escape is decoded, so that a Windows path keeps
+                        # its backslashes instead of losing them one escape at a time.
+                        if escapes_are_known(optval):
                             optval = parse_value(optval)
                     elif quote_open:
                         # Opens quoting and does not close: appears to start multi-line quoting.

test/fixtures/git_config_unquoted_escapes

@@ -0,0 +1,12 @@
+[custom]
+  hasnewline = first\nsecond
+  hastab = first\tsecond
+  hasbackslash = foo\\bar
+  hasquote = ab\"cd
+  hastrailingbackslash = word\\
+  ordinary = hello world
+  withcolon = host:port
+  withequals = key=value
+  withhash = value#notcomment
+  hasunknownescape = foo\qbar
+  haswindowspath = C:\Users\RUNNER~1\AppData\Local\Temp\test_foo

test/test_config.py

@@ -365,7 +365,7 @@ def test_backslash_line_continuation(self):
             (b"[a]\n\tk = one\\\n two ; ignored\n", "one two"),
             (b'[a]\n\tk = one\\\n "two"\n', "one two"),
             (b"[a]\n\tk = one\\\n two\\tthree\n", "one two\tthree"),
-            (b"[a]\n\tk = val\\\\\n next\n", "val\\\\"),
+            (b"[a]\n\tk = val\\\\\n next\n", "val\\"),
             (b"[a]\n\tk = end\\\n", "end"),
             (b"[alias]\n\tco = checkout \\\n\t\t-v\n", "checkout \t\t-v"),
         ]
@@ -1209,6 +1209,30 @@ def test_config_with_quotes_containing_escapes(self):
         # Cases without quotes should still parse correctly even after those, too.
         self.assertEqual(cr.get("custom", "unquoted"), "good evening")
 
+    def test_config_with_unquoted_escapes(self):
+        """Decode git's escape sequences in unquoted values, but only when every
+        backslash in the value is part of a known escape."""
+        cr = GitConfigParser(fixture_path("git_config_unquoted_escapes"), read_only=True)
+
+        self.assertEqual(cr.get("custom", "hasnewline"), "first\nsecond")
+        self.assertEqual(cr.get("custom", "hastab"), "first\tsecond")
+        self.assertEqual(cr.get("custom", "hasbackslash"), R"foo\bar")
+        self.assertEqual(cr.get("custom", "hasquote"), 'ab"cd')
+        self.assertEqual(cr.get("custom", "hastrailingbackslash"), "word\\")
+
+        # Git rejects an unknown escape rather than decoding it. GitPython keeps
+        # such a value literal instead of rejecting it, which is what keeps a
+        # Windows path usable, so no backslash in one may be decoded: doing so
+        # would turn the \t of \Temp\test into a tab while leaving \U alone.
+        self.assertEqual(cr.get("custom", "hasunknownescape"), R"foo\qbar")
+        self.assertEqual(cr.get("custom", "haswindowspath"), R"C:\Users\RUNNER~1\AppData\Local\Temp\test_foo")
+
+        # Values without escapes keep parsing as before.
+        self.assertEqual(cr.get("custom", "ordinary"), "hello world")
+        self.assertEqual(cr.get("custom", "withcolon"), "host:port")
+        self.assertEqual(cr.get("custom", "withequals"), "key=value")
+        self.assertEqual(cr.get("custom", "withhash"), "value")
+
     def test_get_values_works_without_requiring_any_other_calls_first(self):
         file_obj = self._to_memcache(fixture_path("git_config_multiple"))
         cr = GitConfigParser(file_obj, read_only=True)