Issue #4.

Author: eterey

pyvalid/__init__.py

@@ -6,7 +6,7 @@
 
 accepts = Accepts
 returns = Returns
-version = '0.8'
+version = '0.9'
 
 
 __all__ = [

pyvalid/validators.py

@@ -1,7 +1,8 @@
 import sys
+import re
 from abc import ABCMeta, abstractmethod
 from pyvalid import accepts
-from collections import Iterable, Container, Callable
+from collections import Iterable, Container, Callable, Sized
 from six import with_metaclass
 
 
@@ -26,30 +27,24 @@ class AbstractValidator(with_metaclass(ABCMeta, Validator)):
     def checkers(self):
         raise NotImplementedError
 
-    @property
-    @abstractmethod
-    def settings(self):
-        raise NotImplementedError
-
-    @settings.setter
-    @abstractmethod
-    def settings(self, value):
-        raise NotImplementedError
-
     @abstractmethod
     def __call__(self, val):
         raise NotImplementedError
 
     def __init__(self):
-        for key, val in list(self.settings.items()):
-            if (key not in self.checkers) or (val is None):
-                del self.settings[key]
+        Validator.__init__(self, self)
+        for checker_func, checker_args in list(self.checkers.items()):
+            try:
+                to_del = checker_args[0] is None
+            except:
+                to_del = True
+            if to_del:
+                del self.checkers[checker_func]
 
     def _check(self, val):
         valid = True
-        for checker_name, checker_arg in self.settings.items():
-            checker = self.checkers[checker_name]
-            valid = checker(val, checker_arg)
+        for checker_func, checker_args in self.checkers.items():
+            valid = checker_func(val, *checker_args)
             if not valid:
                 break
         return valid
@@ -85,14 +80,6 @@ def in_range_checker(cls, val, in_range):
     def not_in_range_checker(cls, val, not_in_range):
         return not cls.in_range_checker(val, not_in_range)
 
-    @property
-    def settings(self):
-        return self.__settings
-
-    @settings.setter
-    def settings(self, value):
-        self.__settings = value
-
     @property
     def checkers(self):
         return self.__checkers
@@ -102,12 +89,13 @@ def checkers(self):
         in_range=[Iterable, Container], not_in_range=[Iterable, Container]
     )
     def __init__(self, **kwargs):
-        self.__settings = kwargs
         self.__checkers = {
-            'min_val': NumberValidator.min_val_checker,
-            'max_val': NumberValidator.max_val_checker,
-            'in_range': NumberValidator.in_range_checker,
-            'not_in_range': NumberValidator.not_in_range_checker
+            NumberValidator.min_val_checker: [kwargs.get('min_val', None)],
+            NumberValidator.max_val_checker: [kwargs.get('max_val', None)],
+            NumberValidator.in_range_checker: [kwargs.get('in_range', None)],
+            NumberValidator.not_in_range_checker: [
+                kwargs.get('not_in_range', None)
+            ]
         }
         AbstractValidator.__init__(self)
 
@@ -143,29 +131,35 @@ def in_range_checker(cls, val, in_range):
     def not_in_range_checker(cls, val, not_in_range):
         return not cls.in_range_checker(val, not_in_range)
 
-    @property
-    def settings(self):
-        return self.__settings
-
-    @settings.setter
-    def settings(self, value):
-        self.__settings = value
+    @classmethod
+    def re_checker(cls, val, pattern, flags=0):
+        try:
+            match_obj = re.match(pattern, val, flags)
+            is_valid = match_obj is not None
+        except re.error:
+            is_valid = False
+        return is_valid
 
     @property
     def checkers(self):
         return self.__checkers
 
     @accepts(
         object, min_len=int, max_len=int,
-        in_range=[Iterable, Container], not_in_range=[Iterable, Container]
+        in_range=[Iterable, Container], not_in_range=[Iterable, Container],
+        re_pattern=str, re_flags=int
     )
     def __init__(self, **kwargs):
-        self.__settings = kwargs
         self.__checkers = {
-            'min_len': StringValidator.min_len_checker,
-            'max_len': StringValidator.max_len_checker,
-            'in_range': StringValidator.in_range_checker,
-            'not_in_range': StringValidator.not_in_range_checker
+            StringValidator.min_len_checker: [kwargs.get('min_len', None)],
+            StringValidator.max_len_checker: [kwargs.get('max_len', None)],
+            StringValidator.in_range_checker: [kwargs.get('in_range', None)],
+            StringValidator.not_in_range_checker: [
+                kwargs.get('not_in_range', None)
+            ],
+            StringValidator.re_checker: [
+                kwargs.get('re_pattern', None), kwargs.get('re_flags', 0)
+            ]
         }
         AbstractValidator.__init__(self)
 

tests/test_string_validator.py

@@ -1,5 +1,6 @@
 import unittest
 from pyvalid.validators import StringValidator
+import re
 
 
 class StringValidatorTestCase(unittest.TestCase):
@@ -32,6 +33,24 @@ def test_not_in_range(self):
         self.assertTrue(validator('Java'))
         self.assertFalse(validator('CPython'))
 
+    def test_re(self):
+        # Allowed characters are: latin alphabet letters and digits
+        validator = StringValidator(re_pattern='^[a-zA-Z0-9]+$')
+        self.assertTrue(validator('pyvalid'))
+        self.assertTrue(validator('42'))
+        self.assertFalse(validator('__pyvalid__'))
+        # Regular expression is broken
+        validator = StringValidator(re_pattern=':)')
+        self.assertFalse(validator('pyvalid'))
+        self.assertFalse(validator(':)'))
+        # Try to use regular expression with flag
+        validator = StringValidator(
+            re_pattern='^pyvalid$', re_flags=re.IGNORECASE
+        )
+        self.assertTrue(validator('pyvalid'))
+        self.assertTrue(validator('PyValid'))
+        self.assertFalse(validator('42'))
+
     def test_mixed(self):
         validator = StringValidator(
             min_len=6, max_len=64,