Implement 'SRE_Pattern.split'.

Author: fangerer

graalpython/com.oracle.graal.python.test/src/tests/test_re.py

@@ -244,6 +244,59 @@ def test_symbolic_groups(self):
             self.checkPatternError(r'(?(-1))', "bad character in group name '-1'", 3)
             self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
 
+    def test_re_split(self):
+        for string in ":a:b::c", S(":a:b::c"):
+            self.assertTypedEqual(re.split(":", string),
+                                  ['', 'a', 'b', '', 'c'])
+            self.assertTypedEqual(re.split(":+", string),
+                                  ['', 'a', 'b', 'c'])
+            self.assertTypedEqual(re.split("(:+)", string),
+                                  ['', ':', 'a', ':', 'b', '::', 'c'])
+        for string in (b":a:b::c", B(b":a:b::c"), bytearray(b":a:b::c"),
+                       memoryview(b":a:b::c")):
+            self.assertTypedEqual(re.split(b":", string),
+                                  [b'', b'a', b'b', b'', b'c'])
+            self.assertTypedEqual(re.split(b":+", string),
+                                  [b'', b'a', b'b', b'c'])
+            self.assertTypedEqual(re.split(b"(:+)", string),
+                                  [b'', b':', b'a', b':', b'b', b'::', b'c'])
+        for a, b, c in ("\xe0\xdf\xe7", "\u0430\u0431\u0432",
+                        "\U0001d49c\U0001d49e\U0001d4b5"):
+            string = ":%s:%s::%s" % (a, b, c)
+            self.assertEqual(re.split(":", string), ['', a, b, '', c])
+            self.assertEqual(re.split(":+", string), ['', a, b, c])
+            self.assertEqual(re.split("(:+)", string),
+                             ['', ':', a, ':', b, '::', c])
+
+        self.assertEqual(re.split("(?::+)", ":a:b::c"), ['', 'a', 'b', 'c'])
+        self.assertEqual(re.split("(:)+", ":a:b::c"),
+                         ['', ':', 'a', ':', 'b', ':', 'c'])
+        self.assertEqual(re.split("([b:]+)", ":a:b::c"),
+                         ['', ':', 'a', ':b::', 'c'])
+        self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
+                         ['', None, ':', 'a', None, ':', '', 'b', None, '',
+                          None, '::', 'c'])
+        self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
+                         ['', 'a', '', '', 'c'])
+
+        for sep, expected in [
+            (':*', ['', 'a', 'b', 'c']),
+            ('(?::*)', ['', 'a', 'b', 'c']),
+            ('(:*)', ['', ':', 'a', ':', 'b', '::', 'c']),
+            ('(:)*', ['', ':', 'a', ':', 'b', ':', 'c']),
+        ]:
+            with self.subTest(sep=sep), self.assertWarns(FutureWarning):
+                self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
+
+        for sep, expected in [
+            ('', [':a:b::c']),
+            (r'\b', [':a:b::c']),
+            (r'(?=:)', [':a:b::c']),
+            (r'(?<=:)', [':a:b::c']),
+        ]:
+            with self.subTest(sep=sep), self.assertRaises(ValueError):
+                self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
+
     def test_ignore_case_set(self):
         self.assertTrue(re.match(r'[19A]', 'A', re.I))
         self.assertTrue(re.match(r'[19a]', 'a', re.I))

graalpython/lib-graalpython/_sre.py

@@ -354,6 +354,28 @@ def sub(self, repl, string, count=0):
         except BaseException:
             return self.__compile_cpython_sre().sub(repl, string, count)
 
+    def split(self, string, maxsplit=0):
+        n = 0
+        try:
+            pattern = self.__tregex_compile(self.pattern)
+            result = []
+            pos = 0
+            progress = True
+            while (maxsplit == 0 or n < maxsplit) and pos <= len(string) and progress:
+                match_result = tregex_call_safe(pattern.exec, string, pos)
+                if not match_result.isMatch:
+                    break
+                n += 1
+                start = match_result.start[0]
+                end = match_result.end[0]
+                result.append(string[pos:start])
+                pos = end
+                progress = (start != end)
+            result.append(string[pos:])
+            return result
+        except BaseException:
+            return self.__compile_cpython_sre().split(string, maxsplit)
+
 
 compile = SRE_Pattern