davidblewett
diff --git a/‎README.rst
Lines changed: 0 additions & 2 deletions b/‎README.rst
Lines changed: 0 additions & 2 deletions
diff --git a/‎include/rure.h
Lines changed: 92 additions & 1 deletion b/‎include/rure.h
Lines changed: 92 additions & 1 deletion
diff --git a/‎rure/lib.py
Lines changed: 85 additions & 0 deletions b/‎rure/lib.py
Lines changed: 85 additions & 0 deletions
diff --git a/‎rure/tests/test_rureset.py
Lines changed: 47 additions & 0 deletions b/‎rure/tests/test_rureset.py
Lines changed: 47 additions & 0 deletions
diff --git a/‎setup.py
Lines changed: 1 addition & 1 deletion b/‎setup.py
Lines changed: 1 addition & 1 deletion
@@ -68,8 +68,6 @@ There are a few things missing from this package that are present in the Rust AP
 There's no particular (known) reason why they don't, they just haven't been
 implemented yet.
 
-* RegexSet, which permits matching multiple regular expressions simultaneously
-  in a single linear time search.
 * Splitting a string by a regex.
 * Replacing regex matches in a string with some other text.
 
 
@@ -28,6 +28,13 @@ extern "C" {
  */
 typedef struct rure rure;
 
+/*
+ * rure_set is the type of a set of compiled regular expressions.
+ *
+ * A rure can be safely used from multiple threads simultaneously.
+ */
+typedef struct rure_set rure_set;
+
 /*
  * rure_options is the set of non-flag configuration options for compiling
  * a regular expression. Currently, only two options are available: setting
@@ -165,7 +172,7 @@ rure *rure_compile(const uint8_t *pattern, size_t length,
 /*
  * rure_free frees the given compiled regular expression.
  *
- * This must be called at most once.
+ * This must be called at most once for any rure.
  */
 void rure_free(rure *re);
 
@@ -446,6 +453,90 @@ void rure_options_size_limit(rure_options *options, size_t limit);
  */
 void rure_options_dfa_size_limit(rure_options *options, size_t limit);
 
+/*
+ * rure_compile_set compiles the given list of patterns into a single regular
+ * expression which can be matched in a linear-scan. Each pattern in patterns
+ * must be valid UTF-8 and the length of each pattern in patterns corresponds
+ * to a byte length in patterns_lengths.
+ *
+ * The number of patterns to compile is specified by patterns_count. patterns
+ * must contain at least this many entries.
+ *
+ * flags is a bitfield. Valid values are constants declared with prefix
+ * RURE_FLAG_.
+ *
+ * options contains non-flag configuration settings. If it's NULL, default
+ * settings are used. options may be freed immediately after a call to
+ * rure_compile.
+ *
+ * error is set if there was a problem compiling the pattern.
+ *
+ * The compiled expression set returned may be used from multiple threads.
+ */
+rure_set *rure_compile_set(const uint8_t **patterns,
+                           const size_t *patterns_lengths,
+                           size_t patterns_count,
+                           uint32_t flags,
+                           rure_options *options,
+                           rure_error *error);
+
+/*
+ * rure_set_free frees the given compiled regular expression set.
+ *
+ * This must be called at most once for any rure_set.
+ */
+void rure_set_free(rure_set *re);
+
+/*
+ * rure_is_match returns true if and only if any regexes within the set
+ * match anywhere in the haystack. Once a match has been located, the
+ * matching engine will quit immediately.
+ *
+ * haystack may contain arbitrary bytes, but ASCII compatible text is more
+ * useful. UTF-8 is even more useful. Other text encodings aren't supported.
+ * length should be the number of bytes in haystack.
+ *
+ * start is the position at which to start searching. Note that setting the
+ * start position is distinct from incrementing the pointer, since the regex
+ * engine may look at bytes before the start position to determine match
+ * information. For example, if the start position is greater than 0, then the
+ * \A ("begin text") anchor can never match.
+ */
+bool rure_set_is_match(rure_set *re, const uint8_t *haystack, size_t length,
+                       size_t start);
+
+/*
+ * rure_set_matches compares each regex in the set against the haystack and
+ * modifies matches with the match result of each pattern. Match results are
+ * ordered in the same way as the rure_set was compiled. For example,
+ * index 0 of matches corresponds to the first pattern passed to
+ * `rure_compile_set`.
+ *
+ * haystack may contain arbitrary bytes, but ASCII compatible text is more
+ * useful. UTF-8 is even more useful. Other text encodings aren't supported.
+ * length should be the number of bytes in haystack.
+ *
+ * start is the position at which to start searching. Note that setting the
+ * start position is distinct from incrementing the pointer, since the regex
+ * engine may look at bytes before the start position to determine match
+ * information. For example, if the start position is greater than 0, then the
+ * \A ("begin text") anchor can never match.
+ *
+ * matches must be greater than or equal to the number of patterns the
+ * rure_set was compiled with.
+ *
+ * Only use this function if you specifically need to know which regexes
+ * matched within the set. To determine if any of the regexes matched without
+ * caring which, use rure_set_is_match.
+ */
+bool rure_set_matches(rure_set *re, const uint8_t *haystack, size_t length,
+                      size_t start, bool *matches);
+
+/*
+ * rure_set_len returns the number of patterns rure_set was compiled with.
+ */
+size_t rure_set_len(rure_set *re);
+
 /*
  * rure_error_new allocates space for an error.
  *
 
@@ -250,3 +250,88 @@ def shortest_match(self, haystack, start=0):
         end = ffi.new('size_t *')
         if _lib.rure_shortest_match(self._ptr, haystack, hlen, start, end):
             return end[0]
+
+
+class RureSet(object):
+    """ Match multiple (possibly overlapping) regular expressions in a single
+    scan.
+
+    A regex set corresponds to the union of two or more regular expressions.
+    That is, a regex set will match text where at least one of its constituent
+    regular expressions matches. A regex set as its formulated here provides a
+    touch more power: it will also report which regular expressions in the set
+    match. Indeed, this is the key difference between regex sets and a single
+    Regex with many alternates, since only one alternate can match at a time.
+    """
+    def __init__(self, res, flags=DEFAULT_FLAGS, **options):
+
+        """ Compiles a regular expression. Once compiled, it can be used
+        repeatedly to search, split or replace text in a string.
+
+        :param res:     List of Bytestring expressions to compile
+        :param flags:   Bitmask of flags
+        :param kwargs:  Config options to pass (size_limit, dfa_size_limit)
+        """
+
+        if not all(isinstance(re, bytes) for re in res):
+            raise TypeError("'rure.lib.RureSet' must be instantiated with a "
+                            "list of bytestrings as first argument.")
+
+        self._err = ffi.gc(_lib.rure_error_new(), _lib.rure_error_free)
+        self._opts = ffi.gc(_lib.rure_options_new(), _lib.rure_options_free)
+        self.options = options
+        if 'size_limit' in options:
+            _lib.rure_options_size_limit(self._opts, options['size_limit'])
+        if 'dfa_size_limit' in options:
+            _lib.rure_options_dfa_size_limit(self._opts,
+                                             options['dfa_size_limit'])
+
+        patterns = []
+        patterns_lengths = []
+        for re in res:
+            patterns.append(ffi.new("uint8_t []", re))
+            patterns_lengths.append(len(re))
+
+        s = checked_call(
+            _lib.rure_compile_set,
+            self._err,
+            ffi.new("uint8_t *[]", patterns),
+            ffi.new("size_t []", patterns_lengths),
+            len(patterns),
+            flags,
+            self._opts)
+        self._ptr = ffi.gc(s, _lib.rure_set_free)
+
+    def __len__(self):
+        return _lib.rure_set_len(self._ptr)
+
+    @accepts_bytes
+    def is_match(self, haystack, start=0):
+        """
+        Returns true if and only if one of the regexs matches the string
+        given.
+
+        It is recommended to use this method if all you need to do is test
+        a match, since the underlying matching engine may be able to do less
+        work.
+        """
+        return bool(_lib.rure_set_is_match(
+            self._ptr,
+            haystack,
+            len(haystack),
+            start
+        ))
+
+    @accepts_bytes
+    def matches(self, haystack, start=0):
+        """
+        Returns a list of booleans indicating whether the regex at each index
+        was matched in the string given
+        """
+        matches = ffi.new("bool[]", len(self))
+        _lib.rure_set_matches(self._ptr,
+                              haystack,
+                              len(haystack),
+                              start,
+                              matches)
+        return [bool(match) for match in matches]
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import unittest
+
+from rure.exceptions import CompiledTooBigError, RegexSyntaxError
+from rure.lib import CASEI, RureSet
+
+class TestRureSet(unittest.TestCase):
+    def test_is_match(self):
+        haystack = b"snowman: \xE2\x98\x83"
+        res = RureSet([b"\\p{So}"])
+        self.assertIsNotNone(res.is_match(haystack))
+
+    def test_matches(self):
+        haystack = b"foobar"
+        res = RureSet([b"baz", b"bar", b"foo"])
+        self.assertEqual(res.matches(haystack), [False, True, True])
+
+    def test_set_len(self):
+        res = RureSet([b"baz", b"bar", b"foo"])
+        self.assertEqual(len(res), 3)
+
+    def test_flags(self):
+        """Test whether we can set the flags correctly.
+
+        In this case, we disable all flags, which includes disabling
+        Unicode mode. When we disable Unicode mode, we can match
+        arbitrary possibly invalid UTF-8 bytes, such as \xFF.
+        (When Unicode mode is enabled, \xFF won't match .)
+        """
+        pattern = [b"."]
+        haystack = b"\xFF"
+        res = RureSet(pattern, flags=CASEI)
+        self.assertTrue(res.is_match(haystack))
+
+    def test_compile_error(self):
+        try:
+            RureSet([b"("])
+        except RegexSyntaxError as err:
+            self.assertIn("Unclosed parenthesis", err.message)
+
+    def test_compile_error_size_limit(self):
+        try:
+            RureSet([b"\\w{100}"], size_limit=0)
+        except CompiledTooBigError as err:
+            self.assertIn("exceeds size", err.message)
@@ -15,7 +15,7 @@
 
 setup(
     name='rure',
-    version='0.1.1',
+    version='0.1.2',
     author='David Blewett',
     author_email='david@dawninglight.net',
     description=('Python bindings for the Rust `regex` create. '