fix: raise instead of silently corrupting output on an unresolvable delimiter sentinel

nickname_delimiters/maiden_delimiters string values that don't resolve
to a real Constants.regexes key used to fall back to RegexTupleManager's
EMPTY_REGEX default. That's not a harmless no-op: EMPTY_REGEX matches
at every character position, so handle_match() fired repeatedly and
appended '' into the bucket's list each time, producing a truthy
whitespace-only nickname/maiden while leaving the intended delimiter's
content (e.g. literal parentheses) unstripped elsewhere in the name.

Found independently by two review agents with working reproductions
while auditing PR #199. Now raises ValueError naming the bad key
instead. To keep Constants(regexes=<minimal custom set>) working
(confirmed via the existing test_override_regex), nickname_delimiters
is only seeded with a built-in name if it's actually present in the
regexes passed to the constructor -- so a caller who deliberately
drops e.g. "parenthesis" from a custom regexes set doesn't end up with
a dangling sentinel that looks like a mistake.

Author: derek73

nameparser/config/__init__.py

@@ -485,10 +485,14 @@ def __init__(self,
         # routes to without losing that live link. maiden_delimiters starts
         # empty -- maiden is off until a caller routes a delimiter to it.
         # See issue #22.
+        # Only seed a built-in name if it's actually present in self.regexes --
+        # a caller who overrides regexes with a minimal custom set (dropping
+        # e.g. "parenthesis" entirely) shouldn't end up with a dangling
+        # string sentinel that parse_nicknames() would treat as a mistake.
+        # See parse_nicknames()'s fail-loud check on an unresolvable sentinel.
         self.nickname_delimiters = TupleManager[re.Pattern[str] | str]({
-            'quoted_word': 'quoted_word',
-            'double_quotes': 'double_quotes',
-            'parenthesis': 'parenthesis',
+            name: name for name in ('quoted_word', 'double_quotes', 'parenthesis')
+            if name in self.regexes
         })
         self.maiden_delimiters = TupleManager[re.Pattern[str] | str]()
         self.patronymic_name_order = patronymic_name_order

nameparser/parser.py

@@ -922,15 +922,33 @@ def _handle(m: 're.Match[str]') -> str:
         # delimiter value names a Constants.regexes entry, resolved via
         # getattr() so overriding e.g. self.C.regexes.parenthesis keeps
         # working; anything else is already a compiled pattern, added
-        # directly by a caller.
+        # directly by a caller. Unlike a caller directly querying
+        # self.C.regexes (where RegexTupleManager's EMPTY_REGEX default for
+        # an unknown attribute is harmless -- the caller sees the pattern and
+        # can react to it), a bad string here is an internal cross-reference
+        # the delimiter dict itself is responsible for keeping valid.
+        # EMPTY_REGEX matches the empty string at every position, so
+        # silently falling back to it would not just skip the delimiter --
+        # handle_match() would fire on every zero-width match and append ''
+        # into the bucket's list repeatedly, producing a truthy
+        # whitespace-only nickname/maiden while leaving the real delimited
+        # content (e.g. literal parentheses) unstripped. Fail loudly instead.
         for bucket, delimiters in (
             ('nickname', self.C.nickname_delimiters),
             ('maiden', self.C.maiden_delimiters),
         ):
             target_list = getattr(self, bucket + '_list')
             _handle_match = handle_match(target_list)
             for raw_pattern in delimiters.values():
-                _re = raw_pattern if isinstance(raw_pattern, re.Pattern) else getattr(self.C.regexes, raw_pattern)
+                if isinstance(raw_pattern, re.Pattern):
+                    _re = raw_pattern
+                elif raw_pattern in self.C.regexes:
+                    _re = getattr(self.C.regexes, raw_pattern)
+                else:
+                    raise ValueError(
+                        f"{bucket}_delimiters references unknown regexes key {raw_pattern!r}. "
+                        f"Known regexes keys: {sorted(self.C.regexes)}"
+                    )
                 self._full_name = _re.sub(_handle_match, self._full_name)
 
     def squash_emoji(self) -> None:

tests/test_nicknames.py

@@ -282,3 +282,29 @@ def test_maiden_appears_in_as_dict_via_routing(self) -> None:
         C.maiden_delimiters['parenthesis'] = C.nickname_delimiters.pop('parenthesis')
         hn = HumanName("Baker (Johnson), Jenny", constants=C)
         self.assertEqual(hn.as_dict()['maiden'], "Johnson")
+
+    def test_unresolvable_string_sentinel_raises(self) -> None:
+        # A string value in nickname_delimiters/maiden_delimiters that
+        # doesn't name a real regexes key used to silently fall back to
+        # EMPTY_REGEX, which matches at every position and corrupts parsing
+        # (appends '' into the bucket repeatedly, and leaves the intended
+        # delimiter's content unstripped elsewhere in the name). It must
+        # raise instead.
+        C = Constants()
+        C.nickname_delimiters['typo'] = 'parenthesus'
+        with pytest.raises(ValueError):
+            HumanName("Jenny (Johnson) Baker", constants=C)
+
+    def test_routing_same_delimiter_to_both_buckets_nickname_wins(self) -> None:
+        # Misuse case: assigning the same key into both dicts instead of
+        # moving it with pop() (as the docs instruct). nickname_delimiters is
+        # processed first in parse_nicknames()'s bucket loop, so it consumes
+        # the match via re.sub() before maiden_delimiters ever sees it --
+        # maiden stays empty. Pinning this precedence so it doesn't silently
+        # change if the bucket processing order is ever reordered.
+        C = Constants()
+        C.maiden_delimiters['parenthesis'] = C.regexes['parenthesis']
+        hn = HumanName("Baker (Johnson), Jenny", constants=C)
+        self.m(hn.nickname, "Johnson", hn)
+        self.m(hn.maiden, "", hn)
+