fix(config): decode escapes in unquoted config values

Git decodes backslash escapes in unquoted configuration values exactly as
it does in quoted ones, 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 changed meaning 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.

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

@@ -606,7 +606,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,9 +619,10 @@ 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:
-                            optval = parse_value(optval)
+                        # Git decodes escape sequences in unquoted values exactly as
+                        # it does in quoted ones, so a value that needs no line
+                        # continuation is parsed the same way.
+                        optval = parse_value(optval)
                     elif quote_open:
                         # Opens quoting and does not close: appears to start multi-line quoting.
                         is_multi_line = True

test/fixtures/git_config_unquoted_escapes

@@ -0,0 +1,10 @@
+[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

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,23 @@ 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):
+        """Interpret Git's escapes in unquoted values, which git decodes just as it
+        does for quoted ones."""
+        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\\")
+
+        # 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)