fix: address PR review feedback on suffix_delimiter

- Filter empty tokens from trailing/leading delimiters to prevent
  silent parse corruption (e.g. "MD-PhD-" with suffix_delimiter="-")
- Clarify no-op note in Constants docstring: both the comma split and
  subsequent strip() make ", " a no-op, not just the comma split
- Correct param docstring: expansion applies to all post-comma parts,
  not just identified suffix groups
- Tighten known-limitation test with concrete field assertions instead
  of a fragile assertNotEqual
- Add tests: trailing delimiter, comma-space no-op, inverted-format
  limitation

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: derek73

nameparser/config/__init__.py

@@ -235,8 +235,9 @@ class Constants:
     ``"RN - CRNA"`` to be parsed as two separate suffixes. Default is
     ``None`` (no additional splitting beyond the standard comma split).
 
-    Note: setting this to ``", "`` is a no-op — comma-splitting already
-    occurs unconditionally before this step.
+    Note: setting this to ``","`` or ``", "`` has no additional effect —
+    the full name is already split on bare commas first, and each resulting
+    part is stripped of surrounding whitespace before this step runs.
 
     Known limitation: the expansion is applied to all post-comma parts, not
     just suffix groups. In inverted format (``"Last, First, suffix"``), the

nameparser/parser.py

@@ -54,8 +54,8 @@ class HumanName:
     :param str initials_format: python initials string formatting
     :param str initials_delimter: string delimiter for initials
     :param str initials_separator: string separator between consecutive initials
-    :param str suffix_delimiter: additional delimiter to split suffix groups
-        after comma-splitting, e.g. ``" - "`` for ``"RN - CRNA"``
+    :param str suffix_delimiter: additional delimiter to split post-comma parts
+        before suffix detection, e.g. ``" - "`` for ``"RN - CRNA"``
     :param str first: first name
     :param str middle: middle name
     :param str last: last name
@@ -631,7 +631,7 @@ def parse_full_name(self) -> None:
         if self.suffix_delimiter and len(parts) > 1:
             expanded = [parts[0]]
             for part in parts[1:]:
-                expanded.extend([p.strip() for p in part.split(self.suffix_delimiter)])
+                expanded.extend([p for p in (p.strip() for p in part.split(self.suffix_delimiter)) if p])
             parts = expanded
 
         log.debug("full_name: %s", self._full_name)

tests/test_suffixes.py

@@ -180,6 +180,26 @@ def test_suffix_delimiter_constants_level(self) -> None:
     def test_suffix_delimiter_none_by_default_known_limitation(self) -> None:
         # Without suffix_delimiter set, " - " between suffixes breaks parsing.
         # This test documents the known limitation — do not "fix" it.
-        # (Passes when first is "RN" or empty — any incorrect parse is acceptable.)
         hn = HumanName("Steven Hardman, RN - CRNA")
-        self.assertNotEqual(hn.first, "Steven")
+        self.m(hn.first, "RN", hn)
+        self.m(hn.last, "Steven Hardman", hn)
+        self.m(hn.suffix, "CRNA", hn)
+
+    def test_suffix_delimiter_trailing_delimiter_ignored(self) -> None:
+        # Trailing delimiter produces an empty token that must be filtered out.
+        # Using a non-whitespace-terminated delimiter so stripping doesn't consume it.
+        hn = HumanName("John Doe, MD-PhD-", suffix_delimiter="-")
+        self.m(hn.first, "John", hn)
+        self.m(hn.last, "Doe", hn)
+        self.m(hn.suffix, "MD, PhD", hn)
+
+    def test_suffix_delimiter_comma_space_is_noop(self) -> None:
+        hn = HumanName("John Doe, MD, PhD", suffix_delimiter=", ")
+        self.m(hn.suffix, "MD, PhD", hn)
+
+    def test_suffix_delimiter_inverted_format_known_limitation(self) -> None:
+        # In inverted format, the first-name part is also split on the delimiter.
+        # "Mary - Kate" becomes two separate parts, causing a wrong parse.
+        # This is a documented limitation — do not "fix" it without a broader solution.
+        hn = HumanName("Doe, Mary - Kate, RN", suffix_delimiter=" - ")
+        self.assertNotEqual(hn.first, "Mary - Kate")