fix: honor initials_separator kwarg in __process_initial__; fix string_format='' in __str__

- `__process_initial__` was reading `self.C.initials_separator` (Constants)
  instead of `self.initials_separator` (per-instance), so the constructor kwarg
  was silently ignored for multi-word name parts
- `__str__` used `if self.string_format:` (truthiness) so `string_format=""`
  fell through to the default format despite the assignment fix in the PR
- Add regression tests for both kwarg paths through the affected code
- Fix `test_initials_separator_multiword_name_part` to set instance attr instead
  of Constants attr, so it tests the now-correct code path
- Correct `Constants.initials_separator` docstring example (requires
  initials_format="{first}{middle}{last}" to produce "J.A.D.")
- Clarify usage.rst: initials_separator only removes intra-group spaces;
  inter-group spacing is still governed by initials_format

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

Author: derek73

docs/usage.rst

@@ -206,12 +206,13 @@ Furthermore, the delimiter for the string output can be set through:
 
 The separator between consecutive initials *within* a name group (e.g. two middle
 names) is controlled by :py:attr:`~nameparser.config.Constants.initials_separator`,
-which defaults to ``" "``. Setting it to ``""`` removes that space.
+which defaults to ``" "``. Setting it to ``""`` removes that space within a group;
+spacing *between* groups is still governed by ``initials_format``.
 
 ``initials_delimiter``, ``initials_separator``, and ``initials_format`` work together:
 
 - ``initials_delimiter`` — appended *after* each individual initial (default ``"."``)
-- ``initials_separator`` — placed *between* consecutive initials in the same group (default ``" "``)
+- ``initials_separator`` — placed *after* the delimiter between consecutive initials in the same group (default ``" "``), so with ``delimiter="."`` and ``separator=" "`` you get ``A. K.``
 - ``initials_format`` — controls how the first, middle, and last groups are arranged
 
 For example, to produce compact period-separated initials with no spaces:

nameparser/config/__init__.py

@@ -223,7 +223,9 @@ class Constants:
 
     With defaults ``initials_delimiter="."`` and ``initials_separator=" "``,
     ``initials()`` produces ``"J. A. D."``. Setting ``initials_separator=""``
-    with ``initials_delimiter="."`` produces ``"J.A.D."``.
+    with ``initials_delimiter="."`` and ``initials_format="{first}{middle}{last}"``
+    produces ``"J.A.D."``. With the default ``initials_format``, group-level
+    spacing from the template is still applied.
     """
 
     empty_attribute_default = ''

nameparser/parser.py

@@ -179,7 +179,7 @@ def __next__(self) -> str:
             return getattr(self, self._members[c]) or next(self)
 
     def __str__(self) -> str:
-        if self.string_format:
+        if self.string_format is not None:
             # string_format = "{title} {first} {middle} {last} {suffix} ({nickname})"
             _s = self.string_format.format(**self.as_dict())
             # remove trailing punctuation from missing nicknames
@@ -243,7 +243,7 @@ def __process_initial__(self, name_part: str, firstname: bool = False) -> str:
                 if not (self.is_prefix(part) or self.is_conjunction(part)) or firstname:
                     initials.append(part[0])
         if len(initials) > 0:
-            return self.C.initials_separator.join(initials)
+            return self.initials_separator.join(initials)
         else:
             return self.C.empty_attribute_default
 

tests/test_initials.py

@@ -155,11 +155,23 @@ def test_constructor_multiple(self) -> None:
         self.m(hn.last, "lastname", hn)
         self.m(hn.title, "mytitle", hn)
 
+    def test_initials_separator_kwarg_multiword_part(self) -> None:
+        # Regression: initials_separator kwarg must flow into __process_initial__
+        # for multi-word name parts, not just into the initials() join calls.
+        hn = HumanName("", initials_separator="")
+        result = hn.__process_initial__("Van Berg", firstname=True)
+        self.assertEqual(result, "VB")
+
+    def test_string_format_empty_string_kwarg(self) -> None:
+        # Regression: string_format='' was silently ignored due to `or` defaulting
+        hn = HumanName("John Doe", string_format="")
+        self.assertEqual(str(hn), "")
+
     def test_initials_separator_multiword_name_part(self) -> None:
         # __process_initial__ splits on spaces internally for multi-word tokens;
         # initials_separator must flow through there too.
         hn = HumanName("", constants=None)
-        hn.C.initials_separator = ""
+        hn.initials_separator = ""
         # Directly exercise __process_initial__ with a two-word part
         result = hn.__process_initial__("Van Berg", firstname=True)
         self.assertEqual(result, "VB")