don't crash if regexes not defined

test can override all of the constants

Author: derek73

nameparser/parser.py

@@ -2,6 +2,7 @@
 from __future__ import unicode_literals
 
 import sys
+import re
 from operator import itemgetter
 from itertools import groupby
 
@@ -467,11 +468,14 @@ def post_process(self):
         self.handle_capitalization()
 
     def fix_phd(self):
-        _re = self.C.regexes.phd
-        match = _re.search(self._full_name)
-        if match:
-            self.suffix_list.append(match.group(1))
-            self._full_name = _re.sub('', self._full_name)
+        try:
+            _re = self.C.regexes.phd
+            match = _re.search(self._full_name)
+            if match:
+                self.suffix_list.append(match.group(1))
+                self._full_name = _re.sub('', self._full_name)
+        except AttributeError:
+            pass
 
     def parse_nicknames(self):
         """
@@ -485,10 +489,12 @@ def parse_nicknames(self):
         Loops through 3 :py:data:`~nameparser.config.regexes.REGEXES`;
         `quoted_word`, `double_quotes` and `parenthesis`.
         """
-
-        re_quoted_word = self.C.regexes.quoted_word
-        re_double_quotes = self.C.regexes.double_quotes
-        re_parenthesis = self.C.regexes.parenthesis
+        
+        empty_re = re.compile("")
+        
+        re_quoted_word = self.C.regexes.quoted_word or empty_re
+        re_double_quotes = self.C.regexes.double_quotes or empty_re
+        re_parenthesis = self.C.regexes.parenthesis or empty_re
 
         for _re in (re_quoted_word, re_double_quotes, re_parenthesis):
             if _re.search(self._full_name):
@@ -704,7 +710,7 @@ def parse_pieces(self, parts, additional_parts_count=0):
         # constants so they get parsed correctly later
         for part in output:
             # if this part has a period not at the beginning or end
-            if self.C.regexes.period_not_at_end.match(part):
+            if self.C.regexes.period_not_at_end and self.C.regexes.period_not_at_end.match(part):
                 # split on periods, any of the split pieces titles or suffixes?
                 # ("Lt.Gov.")
                 period_chunks = part.split(".")

tests.py

@@ -20,14 +20,15 @@
 """
 
 import logging
+import re
 try:
     import dill
 except ImportError:
     dill = False
 
 from nameparser import HumanName
 from nameparser.util import u
-from nameparser.config import Constants
+from nameparser.config import Constants, TupleManager
 
 log = logging.getLogger('HumanName')
 
@@ -199,6 +200,59 @@ def test_surnames_attribute(self):
         hn = HumanName("John Edgar Casey Williams III")
         self.m(hn.surnames, "Edgar Casey Williams", hn)
 
+    def test_override_constants(self):
+        C = Constants()
+        hn = HumanName(constants=C)
+        self.assertTrue(hn.C is C)
+
+    def test_override_regex(self):
+        var = TupleManager([("spaces", re.compile(r"\s+", re.U)),])
+        C = Constants(regexes=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(hn.C.regexes == var)
+
+    def test_override_titles(self):
+        var = ["abc","def"]
+        C = Constants(titles=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.titles) == sorted(var))
+
+    def test_override_first_name_titles(self):
+        var = ["abc","def"]
+        C = Constants(first_name_titles=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.first_name_titles) == sorted(var))
+
+    def test_override_prefixes(self):
+        var = ["abc","def"]
+        C = Constants(prefixes=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.prefixes) == sorted(var))
+
+    def test_override_suffix_acronyms(self):
+        var = ["abc","def"]
+        C = Constants(suffix_acronyms=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.suffix_acronyms) == sorted(var))
+
+    def test_override_suffix_not_acronyms(self):
+        var = ["abc","def"]
+        C = Constants(suffix_not_acronyms=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.suffix_not_acronyms) == sorted(var))
+
+    def test_override_conjunctions(self):
+        var = ["abc","def"]
+        C = Constants(conjunctions=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(sorted(hn.C.conjunctions) == sorted(var))
+
+    def test_override_capitalization_exceptions(self):
+        var = TupleManager([("spaces", re.compile(r"\s+", re.U)),])
+        C = Constants(capitalization_exceptions=var)
+        hn = HumanName(constants=C)
+        self.assertTrue(hn.C.capitalization_exceptions == var)
+
 
 class FirstNameHandlingTests(HumanNameTestBase):
     def test_first_name(self):