Review follow-ups: pin cross-constants semantics, fix inert test token

The custom-constants test used 'chancellor', which is already a default
title, so it passed without the self.C parse path ever mattering; use a
token that is provably not a default title, with a guard assertion.

Pin the operand asymmetry as deliberate: a str operand is reparsed with
self.C, a HumanName operand is compared as already parsed. Document the
all-empty comparison key for empty/unparsable input in both docstrings
(screen with len(name) == 0), with a test, and add a non-ASCII
case-insensitivity check.

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

Author: derek73

nameparser/parser.py

@@ -311,6 +311,10 @@ def comparison_key(self) -> tuple[str, ...]:
         display settings like ``string_format`` and
         ``empty_attribute_default``.
 
+        Empty or unparsable input yields the all-empty key, so such names
+        all compare equal and collide in dedup; screen them out with
+        ``len(name) == 0`` first.
+
         .. doctest::
 
             >>> HumanName("Dr. Juan Q. Xavier de la Vega III").comparison_key()
@@ -327,7 +331,10 @@ def matches(self, other: 'str | HumanName') -> bool:
         Compare parsed components case-insensitively; the semantic
         replacement for the deprecated ``==``. A ``str`` argument is parsed
         first, using this instance's configuration, so any written form of
-        the same name matches:
+        the same name matches; a ``HumanName`` argument is compared as
+        already parsed — its own configuration determined its components.
+        Two empty or unparsable names match each other; check
+        ``len(name) == 0`` to screen them.
 
         .. doctest::
 

tests/test_python_api.py

@@ -357,13 +357,39 @@ def test_matches_humanname_operand(self) -> None:
         self.assertFalse(hn.matches(HumanName("Jane Smith")))
 
     def test_matches_parses_str_with_instance_constants(self) -> None:
+        # the custom title must not be a default one ('chancellor' is!), or
+        # this passes without the self.C parse path ever mattering
         c = Constants()
-        c.titles.add('chancellor')
-        hn = HumanName("Chancellor Jane Smith", constants=c)
+        c.titles.add('zephyrmark')
+        self.assertNotIn('zephyrmark', CONSTANTS.titles)
+        hn = HumanName("Zephyrmark Jane Smith", constants=c)
         # the str operand is parsed with self.C, so the custom title is
-        # recognized in the comma form; the shared CONSTANTS would not
-        # parse 'chancellor' as a title here
-        self.assertTrue(hn.matches("smith, chancellor jane"))
+        # recognized in the comma form; parsed with the shared CONSTANTS,
+        # 'zephyrmark' would land in first/middle and the keys would differ
+        self.assertTrue(hn.matches("smith, zephyrmark jane"))
+
+    def test_matches_humanname_operand_keeps_its_own_parse(self) -> None:
+        # asymmetry, pinned deliberately: a str operand is reparsed with
+        # self.C, but a HumanName operand is compared as already parsed --
+        # its own constants determined its components
+        c = Constants()
+        c.titles.add('zephyrmark')
+        with_title = HumanName("Zephyrmark Jane Smith", constants=c)
+        default_parse = HumanName("Zephyrmark Jane Smith")
+        self.assertTrue(with_title.matches("Zephyrmark Jane Smith"))
+        self.assertFalse(with_title.matches(default_parse))
+
+    def test_empty_parses_share_a_comparison_key(self) -> None:
+        # documented caveat: empty/unparsable input collapses to the
+        # all-empty key, so such names match each other and collide in
+        # dedup; screen with len(name) == 0 first
+        self.assertTrue(HumanName("").matches(HumanName(",")))
+        self.assertEqual(HumanName("()").comparison_key(),
+                         HumanName("").comparison_key())
+
+    def test_matches_non_ascii_case_insensitive(self) -> None:
+        hn = HumanName("JOSÉ GARCÍA")
+        self.assertTrue(hn.matches("José García"))
 
     def test_matches_rejects_other_types(self) -> None:
         hn = HumanName("John Smith")