fix: parse joined config values as a whole

Git removes each backslash-newline pair before parsing the resulting logical
value. Appending physical lines after processing only the first line left
trailing whitespace, comments, quotes, and recognized escapes literal.

That divergence returned values unlike git config and could preserve comment
text as configuration data.

- Accumulate continuation text before parsing it.
- Apply whitespace, comment, quote, and escape handling once to the complete value.
- Cover each affected syntax form with Git-compatible expectations.

Assisted-by: GPT 5.6
Co-authored-by: GPT 5.6 <codex@openai.com>

Author: Byron

git/config.py

@@ -480,6 +480,32 @@ def is_line_continuation(value: str) -> bool:
                     return False
             return escaped
 
+        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))
+                    escaped = False
+                    continue
+                if char.isspace() and not quoted:
+                    if parsed:
+                        whitespace.append(char)
+                    continue
+                if char in "#;" and not quoted:
+                    break
+                parsed.extend(whitespace)
+                whitespace.clear()
+                if char == "\\":
+                    escaped = True
+                elif char == '"':
+                    quoted = not quoted
+                else:
+                    parsed.append(char)
+            return "".join(parsed)
+
         while True:
             # We assume to read binary!
             line = fp.readline().decode(defenc)
@@ -529,9 +555,10 @@ def is_line_continuation(value: str) -> bool:
                         # A value ending in an odd number of backslashes
                         # continues on the next line, exactly as git does: the
                         # final backslash and the newline are removed and the
-                        # next line is appended verbatim (leading whitespace
-                        # included). An even number means the last backslash
-                        # is escaped and the value ends there.
+                        # 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
@@ -545,6 +572,9 @@ def is_line_continuation(value: str) -> bool:
                             while joined.endswith("\n") or joined.endswith("\r"):
                                 joined = joined[:-1]
                             optval = optval[:-1] + joined
+                            continued = True
+                        if continued:
+                            optval = parse_value(optval)
                     elif optval[-1] != '"':
                         # Opens quoting and does not close: appears to start multi-line quoting.
                         is_multi_line = True

test/test_config.py

@@ -146,10 +146,14 @@ def test_multi_line_config(self):
     def test_backslash_line_continuation(self):
         """An unquoted value ending in a backslash continues on the next line,
         exactly as git config parses it: the final backslash and the newline
-        are removed and the next line is appended verbatim."""
+        are removed before the complete logical value is parsed."""
         cases = [
             (b"[a]\n\tk = line1\\\n line2\n", "line1 line2"),
             (b"[a]\n\tk = one\\\n two\\\n three\n", "one two three"),
+            (b"[a]\n\tk = one\\\n two   \n", "one two"),
+            (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 = end\\\n", "end"),
             (b"[alias]\n\tco = checkout \\\n\t\t-v\n", "checkout \t\t-v"),
@@ -170,6 +174,7 @@ def test_comment_backslash_does_not_continue_value(self, rw_dir):
             config_file.write(b"[a]\n\tk = one\\\n two ; ignored \\\n\tx = two\n")
 
         with GitConfigParser(config_path, read_only=False) as config:
+            self.assertEqual(config.get_value("a", "k"), "one two")
             self.assertEqual(config.get_value("a", "x"), "two")
             config.set_value("a", "added", "three")