Normalize str values in SetManager.__contains__

After #238's follow-ups, SetManager normalizes (lowercase, strip leading/
trailing periods) in add(), remove(), the constructor, and every set
operator -- __contains__ was the lone holdout, so 'Dr.' in c.titles returned
False even though every other operation on the same value succeeded. The ABC
comparison mixins (__le__, __eq__, etc.) route through __contains__, so this
also fixes subset/equality checks against un-normalized operands.

lc() is idempotent, so the parser's own lc()-normalized lookups are
unaffected.

Fixes #244

Author: derek73

nameparser/config/__init__.py

@@ -145,6 +145,14 @@ def __iter__(self) -> Iterator[str]:
         return iter(self.elements)
 
     def __contains__(self, value: object) -> bool:
+        # add()/remove()/the constructor/the operators all normalize (lowercase,
+        # strip leading/trailing periods) before comparing; without the same
+        # normalization here, `'Dr.' in c.titles` returns False even though
+        # every other operation on the same value succeeds (#244). lc() is
+        # idempotent, so this doesn't change the parser's own lc()-normalized
+        # lookups (e.g. `piece.lower() in self.C.conjunctions`).
+        if isinstance(value, str):
+            value = lc(value)
         return value in self.elements
 
     def __len__(self) -> int:

tests/test_constants.py

@@ -124,6 +124,23 @@ def test_set_manager_operators_normalize_like_add(self) -> None:
         # pins __rxor__ separately in case it ever stops aliasing __xor__
         self.assertEqual((['Dr.', 'Esq.'] ^ sm).elements, {'mr', 'esq'})
 
+    def test_set_manager_contains_normalizes_like_add(self) -> None:
+        # add()/remove()/the constructor/the operators all normalize (lowercase,
+        # strip leading/trailing periods) -- __contains__ was the lone holdout,
+        # so `'Dr.' in c.titles` returned False even though every other
+        # operation on the same value succeeded (#244)
+        sm = SetManager(['dr', 'mr'])
+        self.assertIn('Dr.', sm)
+        self.assertIn('MR', sm)
+        self.assertNotIn('Esq.', sm)
+
+    def test_set_manager_le_uses_normalizing_contains(self) -> None:
+        # the ABC comparison mixins route through __contains__, so an
+        # un-normalized membership check would leak into subset/equality too
+        sm = SetManager(['dr', 'mr'])
+        self.assertTrue(sm <= SetManager(['dr', 'mr', 'esq']))
+        self.assertTrue({'Dr.', 'Mr.'} <= sm)
+
     def test_set_manager_rsub_is_order_sensitive(self) -> None:
         # __sub__ and __rsub__ are hand-written separately (subtraction
         # isn't commutative, unlike |/&/^), so a copy-paste operand swap