Merge pull request #33 from wearp/master

Added to Query.search method & tests

Author: msiemens

tests/test_queries.py

@@ -92,6 +92,12 @@ def test_regex():
     assert not query({'val': 'ab.'})
     assert not query({'': None})
 
+    query = where('val').search(r'\d+')
+
+    assert query({'val': 'ab3'})
+    assert not query({'val': 'abc'})
+    assert not query({'val': ''})
+    assert not query({'': None})
 
 def test_custom():
     def test(value):
@@ -158,17 +164,28 @@ def test_has():
     assert query({'key1': {'key2': {'key3': 1}}})
     assert not query({'key1': {'key2': {'key3': 0}}})
 
-    # Test special methods: regex
+    # Test special methods: regex matches
     query = where('key1').has('value').matches(r'\d+')
     assert query({'key1': {'value': '123'}})
     assert not query({'key2': {'value': '123'}})
     assert not query({'key2': {'value': 'abc'}})
 
-    # Test special methods: nested has and regex
+    # Test special methods: regex search
+    query = where('key1').has('value').search(r'\d+')
+    assert query({'key1': {'value': 'a2c'}})
+    assert not query({'key2': {'value': 'a2c'}})
+    assert not query({'key2': {'value': 'abc'}})
+
+    # Test special methods: nested has and regex matches
     query = where('key1').has('x').has('y').matches(r'\d+')
     assert query({'key1': {'x': {'y': '123'}}})
     assert not query({'key1': {'x': {'y': 'abc'}}})
 
+    # Test special method: nested has and regex search
+    query = where('key1').has('x').has('y').search(r'\d+')
+    assert query({'key1': {'x': {'y': 'a2c'}}})
+    assert not query({'key1': {'x': {'y': 'abc'}}})
+    
     # Test special methods: custom test
     query = where('key1').has('int').test(lambda x: x == 3)
     assert query({'key1': {'int': 3}})

tinydb/queries.py

@@ -92,7 +92,20 @@ def matches(self, regex):
         :rtype: QueryRegex
         """
 
-        return QueryRegex(self._key, regex)
+        return QueryRegex(self._key, regex, re_method='match')
+
+    def search(self, regex):
+        """
+        Run a regex test against a dict value.
+
+        >>> where('f1').search(r'\d+')
+        'f1' ~= \d+
+
+        :param regex: The regular expression to pass to ``re.search``
+        :rtype: QueryRegex
+        """
+
+        return QueryRegex(self._key, regex, re_method='search')
 
     def test(self, func):
         """
@@ -411,16 +424,18 @@ def __repr__(self):
         return '({0}) and ({1})'.format(self._cond_1, self._cond_2)
 
 
+
 class QueryRegex(AndOrMixin):
     """
     Run a regex test against a dict value.
 
     See :meth:`.Query.matches`.
     """
 
-    def __init__(self, key, regex):
+    def __init__(self, key, regex, re_method):
         self.regex = regex
         self._key = key
+        self.re_method = re_method
 
     def __call__(self, element):
         """
@@ -429,8 +444,12 @@ def __call__(self, element):
 
         if self._key not in element:
             return False
-
-        return re.match(self.regex, element[self._key])
+        
+        if self.re_method == 'match':
+            return re.match(self.regex, element[self._key])
+    
+        if self.re_method == 'search':
+            return re.search(self.regex, element[self._key])
 
     def __repr__(self):
         return '\'{0}\' ~= {1} '.format(self._key, self.regex)
@@ -478,7 +497,15 @@ def matches(self, regex):
         See :meth:`.Query.matches`.
         """
 
-        self._special = QueryRegex(self._key, regex)
+        self._special = QueryRegex(self._key, regex, re_method='match')
+        return self
+
+    def search(self, regex):
+        """
+        See :meth:`.Query.search`.
+        """
+
+        self._special = QueryRegex(self._key, regex, re_method='search')
         return self
 
     def test(self, func):