A word-final apostrophe is not an unbalanced delimiter

The close sweep added in d993db0 flagged "Mari' Aube'". It should not:
an ambiguity means the part could REASONABLY read two ways where it
sits, and a "'" after a word character cannot -- it is an apostrophe.

"'" is the only delimiter character that occurs inside and at the end
of real name parts, and the least likely of them to mark a nickname.
The same position with a quote IS ambiguous, because quotes do not
appear inside names, so the carve-out is deliberately this one
character:

    "Mari' Aube'"  -> 0 ambiguities
    'Mari" Aube"'  -> 2 ambiguities

#273 excluded the curly apostrophe from the delimiter set outright for
this reason. The straight one has to stay a delimiter (v1's
quoted_word), so it gets the narrower treatment here.

The carve-out is about what PRECEDES the character, so an apostrophe
opening a quote is untouched: "John 'Jack Smith" still reports an
unmatched open. Also allows a preceding period, for initials
("O'B. Smith'").

Corpus back to 0 of 486 reporting, where the naive close sweep had 1.

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

Author: derek73

nameparser/_pipeline/_extract.py

@@ -61,6 +61,24 @@ def _close_ok(text: str, j: int, width: int) -> bool:
     return k >= len(text) or text[k].isspace() or text[k] in COMMA_CHARS
 
 
+def _apostrophe_after_a_word(text: str, j: int, close: str) -> bool:
+    """A "'" directly after a word character is an apostrophe, not a
+    dangling close quote -- "Mari' Aube'", "Ali Baba'".
+
+    An ambiguity means the part could REASONABLY read two ways where it
+    sits, and this one cannot: "'" is the only delimiter character that
+    occurs inside and at the end of real name parts, and it is the
+    least likely of them to mark a nickname. The same position with a
+    quote IS ambiguous, since quotes do not appear inside names, so the
+    carve-out is deliberately this one character. #273 excluded the
+    curly apostrophe from the delimiter set outright for the same
+    reason; the straight one has to stay a delimiter (v1's
+    quoted_word), so it is handled here instead.
+    """
+    return close == "'" and j > 0 and (text[j - 1].isalnum()
+                                       or text[j - 1] == ".")
+
+
 def _overlaps(span: Span, taken: list[Span]) -> bool:
     return any(span.start < t.end and t.start < span.end for t in taken)
 
@@ -191,6 +209,7 @@ def extract_delimited(state: ParseState) -> ParseState:
             start = j + 1
             if (j in reported                      # already an open
                     or not _close_ok(text, j, len(close))
+                    or _apostrophe_after_a_word(text, j, close)
                     or _overlaps(Span(j, j + len(close)), masked)):
                 continue
             reported.add(j)

tests/v2/pipeline/test_extract.py

@@ -199,6 +199,29 @@ def test_unmatched_close_is_reported(text: str, char: str) -> None:
     assert char in parse(text).ambiguities[0].detail
 
 
+def test_word_final_apostrophe_is_not_an_unbalanced_delimiter() -> None:
+    # ambiguity means the part could REASONABLY read two ways where it
+    # sits. A "'" after a word character is an apostrophe -- it is the
+    # one delimiter character that occurs inside and at the end of real
+    # name parts, and the least likely to mark a nickname. The same
+    # position with a quote IS ambiguous, because quotes do not appear
+    # inside names. (#273 excluded the curly apostrophe from the
+    # delimiters entirely for this reason; the straight one is a
+    # delimiter, so it needs the carve-out here instead.)
+    assert parse("Mari' Aube'").ambiguities == ()
+    assert parse("Ali Baba'").ambiguities == ()
+    quoted = parse('Mari" Aube"')
+    assert [a.kind for a in quoted.ambiguities] == \
+        [AmbiguityKind.UNBALANCED_DELIMITER] * 2
+
+
+def test_apostrophe_after_a_space_is_still_reported() -> None:
+    # the carve-out is about what PRECEDES the character: an apostrophe
+    # opening a quote is still an unmatched open when nothing closes it
+    assert [a.kind for a in parse("John 'Jack Smith").ambiguities] == \
+        [AmbiguityKind.UNBALANCED_DELIMITER]
+
+
 @pytest.mark.parametrize("text", [
     "Brian O'connor",       # apostrophe mid-word, not a delimiter
     "O'B. John Smith",