feat: default spec is Derek's chosen format — quoted nickname, parenthesized maiden

'{title} {given} "{nickname}" {middle} {family} ({maiden}) {suffix}':
nickname in the classic quoted position after the given name, maiden
parenthesized after the family. The collapse's existing empty-'""'
and empty-'()' rules cover both decorations, so the née trailing-strip
special case is deleted. Trade-off documented: the quoted nickname
round-trips exactly; parenthesized maiden re-parses as a nickname
(custom 'née {maiden}' spec available for lossless round-trip).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derek73

docs/release_log.rst

@@ -28,7 +28,7 @@ Release Log
     - Change suffix-delimiter rendering: with a custom ``Policy``/``Constants`` suffix delimiter configured (e.g. ``suffix_delimiter="/"``, ``"John Smith, RN/CRNA"``), 1.x split the token and rendered ``suffix="RN, CRNA"``; 2.0 keeps the no-space delimiter-core token whole (``suffix="RN/CRNA"``) -- role assignment is unchanged, only rendering differs (anti-#100, migration plan deviation 5; ``tests/v2/cases.py`` row ``suffix_delimiter_no_space_core``). Only fires with a non-default policy, so it does not appear in the (default-policy) differential corpus
     - Change ``comparison_key()``/``matches()`` (both APIs) to fold components with ``str.casefold()`` where 1.4 used ``str.lower()``: Unicode case-pair forms now compare equal -- ``"STRASSE"`` matches ``"Straße"``, and a Greek final-sigma variant matches its regular-sigma form. Strictly more permissive (anything 1.4 matched still matches); parse output is unaffected -- vocabulary normalization itself uses ``lower()``, v1-parity (``tests/v2/test_types.py`` row ``test_matches_casefolds_unicode_case_pairs``)
     - Change delimiter-overlap precedence in the 2.0 API: a pair listed in ``Policy.maiden_delimiters`` is dropped from the effective ``nickname_delimiters`` set (maiden wins), so ``Policy(maiden_delimiters={("(", ")")})`` alone routes parenthesized content to ``maiden`` -- no need to rebuild the nickname set. The default nickname set is now the public ``DEFAULT_NICKNAME_DELIMITERS`` constant. The 1.x facade keeps v1's nickname-wins precedence on overlap via a shim-side pre-subtraction, so no ``HumanName`` behavior changes (``tests/v2/cases.py`` row ``maiden_delimiters_win_when_shared``; ``tests/v2/test_config_shim.py`` row ``test_snapshot_overlap_keeps_v1_nickname_precedence``)
-    - Change the 2.0 API's default ``render()``/``str()`` spec to show every non-empty field: ``"{title} {given} {middle} {family} {suffix} ({nickname}) née {maiden}"``. v1's default already showed ``({nickname})``; 2.0 had dropped it (so ``str(parse("Von Johnson (smith)"))`` silently lost the nickname) and adds ``née {maiden}``. Both decorations round-trip -- parentheses re-extract as the nickname and ``née`` is a maiden marker. The ``HumanName`` facade keeps v1's own ``string_format`` default, unchanged (``tests/v2/test_render.py`` row ``test_default_str_includes_nickname_and_maiden``)
+    - Change the 2.0 API's default ``render()``/``str()`` spec to show every non-empty field: ``'{title} {given} "{nickname}" {middle} {family} ({maiden}) {suffix}'``. v1's default already showed the nickname; 2.0 had dropped it (so ``str(parse("Von Johnson (smith)"))`` silently lost it) and never showed the maiden name. The quoted nickname round-trips exactly; the parenthesized maiden re-parses as a nickname (presentation over lossless round-trip -- use ``née {maiden}`` in a custom spec if you need the round-trip). The ``HumanName`` facade keeps v1's own ``string_format`` default, unchanged (``tests/v2/test_render.py`` row ``test_default_str_includes_nickname_and_maiden``)
     - Recognize typographic nickname delimiters by default in BOTH APIs (closes #273): smart quotes (``“Jack”``), German/Polish low-high quotes (``„Hansi“``), Swedish right-right quotes (``”Ann”``), guillemets in both directions (``«Petit»``, ``»Hansi«``, inner spacing tolerated), CJK corner brackets (``「タロ」``/``『ハナ』``), and fullwidth parentheses. In 1.x these leaked into ``middle`` as literal text. Curly *single* quotes stay excluded (U+2019 is the apostrophe in "O’Connor" -- pinned by ``curly_apostrophe_stays_literal``). The v1 keyed idioms work on the new named sentinels (``smart_double_quotes``, ``guillemets``, ...). A delimiter character consumed by another pair's extraction no longer emits a spurious ``unbalanced-delimiter`` ambiguity (``tests/v2/cases.py`` rows ``*_nickname``; ``tests/v2/pipeline/test_extract.py``). Not present in the differential corpus
 
     Everything else in the 486-name differential corpus (built from the

docs/usage.rst

@@ -70,12 +70,13 @@ Nicknames and maiden names
     'Jones'
 
 Both fields appear in the default ``str()`` rendering — the nickname
-in parentheses, the maiden name after ``née``:
+quoted after the given name, the maiden name parenthesized after the
+family name:
 
 .. doctest::
 
     >>> str(parse("Jane (Janie) Smith née Jones"))
-    'Jane Smith (Janie) née Jones'
+    'Jane "Janie" Smith (Jones)'
 
 Comparing names
 ----------------

nameparser/_render.py

@@ -51,13 +51,6 @@ def _collapse(rendered: str) -> str:
                         .replace(' ""', ""))
     rendered = _SPACE_BEFORE_COMMA.sub(",", rendered)
     rendered = _SPACES.sub(" ", rendered.strip())
-    # the default spec's maiden decoration: an empty {maiden} leaves a
-    # trailing bare 'née' (lowercase, exactly the template's spelling
-    # -- a capitalized name 'Née' as content is untouched); on an
-    # all-empty parse the decoration IS the whole string
-    rendered = rendered.removesuffix(" née")
-    if rendered == "née":
-        rendered = ""
     if rendered and _COMMA_CHAR.fullmatch(rendered[-1]):
         rendered = rendered[:-1]
     return rendered.strip(", ")

nameparser/_types.py

@@ -542,16 +542,16 @@ def matches(self, other: str | ParsedName, *,
 
     def render(
         self,
-        spec: str = ("{title} {given} {middle} {family} {suffix} "
-                     "({nickname}) née {maiden}"),
+        spec: str = ('{title} {given} "{nickname}" {middle} {family} '
+                     "({maiden}) {suffix}"),
     ) -> str:
         """Fill the str.format spec from the seven role fields and the
         derived views; empty fields collapse (#254), including the
-        default spec's decorations -- '()' around an absent nickname
-        and a trailing orphaned 'née'. The default shows every
-        non-empty field and round-trips: parentheses re-extract as the
-        nickname and 'née' is a maiden marker. Unknown keys raise
-        KeyError naming the valid fields."""
+        default spec's decorations (empty '""' and '()' wrappers).
+        The default shows every non-empty field: the nickname quoted
+        after the given name, the maiden name parenthesized after the
+        family name. Unknown keys raise KeyError naming the valid
+        fields."""
         import nameparser._render as _render
         return _render.render(self, spec)
 

tests/v2/test_render.py

@@ -71,18 +71,18 @@ def test_render_empty_parse_is_empty_string() -> None:
 
 def test_default_str_includes_nickname_and_maiden() -> None:
     # Derek's terminal find (2026-07-19): str(parse('Von Johnson
-    # (smith)')) dropped the nickname. v1's default string_format
-    # always showed '({nickname})'; the 2.0 default restores it and
-    # adds 'née {maiden}' -- and both decorations round-trip: parens
-    # re-extract as nickname, née is a maiden marker.
+    # (smith)')) dropped the nickname; the default spec now shows all
+    # seven fields -- nickname quoted after the given name, maiden
+    # parenthesized after the family name (Derek's chosen format).
+    # The nickname decoration round-trips exactly; the maiden parens
+    # re-extract as a NICKNAME on reparse (documented trade-off:
+    # presentation over lossless round-trip).
     from nameparser import parse
 
-    assert str(parse("Von Johnson (smith)")) == "Von Johnson (smith)"
-    assert str(parse("Jane Smith née Jones")) == "Jane Smith née Jones"
+    assert str(parse("Von Johnson (smith)")) == 'Von "smith" Johnson'
+    assert str(parse("Jane Smith née Jones")) == "Jane Smith (Jones)"
     both = parse("Jane (Janie) Smith née Jones")
-    assert str(both) == "Jane Smith (Janie) née Jones"
-    reparsed = parse(str(both))
-    assert reparsed.nickname == "Janie" and reparsed.maiden == "Jones"
+    assert str(both) == 'Jane "Janie" Smith (Jones)'
     # no orphaned decoration when the fields are empty
     assert str(parse("Dr. Juan Q. Xavier de la Vega III")) == (
         "Dr. Juan Q. Xavier de la Vega III")