new API

test/parse.py

@@ -1,9 +1,9 @@
 import os.path
 from unittest import TestCase
 
-from kpmatch import PatternParsingError
 import kpmatch.matchers as m
 import kpmatch.parse as p
+from kpmatch.config import Config
 
 
 def join_matchers(first: m.PathMatcher, *others: m.PathMatcher) -> m.PathMatcher:
@@ -13,10 +13,59 @@ def join_matchers(first: m.PathMatcher, *others: m.PathMatcher) -> m.PathMatcher
 
 
 class ParseTests(TestCase):
+    def test_expand_braces(self):
+        cfg = Config()
+        self.assertEqual(
+            [
+                "ab/**/*.def",
+                "ab/ghi",
+                "a?c/**/*.def",
+                "a?c/ghi",
+            ],
+            p._expand_braces(cfg, "a{b,?c}/{**/*.def,ghi}"),
+        )
+
+    def test_parse_braces_notation(self):
+        # braces_notation <- ( fixed_section (braced_section fixed_section)* )? EOS
+        cfg = Config()
+        self.assertEqual(p._parse_braces_notation(cfg, ""), [])
+        self.assertEqual(
+            p._parse_braces_notation(cfg, "a{b,?c}/{**/*.def,ghi}"),
+            [["a"], ["b", "?c"], ["/"], ["**/*.def", "ghi"]],
+        )
+
+    def test_parse_braced_section(self):
+        # braced_section = "{" braces_alternative ("," braces_alternative)* "}"
+        self.assertTupleEqual(
+            p._parse_braced_section("{abc,def}", 0), (["abc", "def"], 9)
+        )
+        self.assertTupleEqual(p._parse_braced_section("{abc}", 0), (["abc"], 5))
+        self.assertTupleEqual(
+            p._parse_braced_section("{a,b,c,}", 0), (["a", "b", "c", ""], 8)
+        )
+        self.assertRaises(p.PatternParsingError, p._parse_braced_section, "abc,def}", 0)
+        self.assertRaises(p.PatternParsingError, p._parse_braced_section, "{abc,def", 0)
+        self.assertRaises(
+            p.PatternParsingError, p._parse_braced_section, "{abc{def}", 0
+        )
+
+    def test_parse_braces_alternative(self):
+        # braces_alternative <- (!("{" / "," / "}") .)+
+        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 0), ("ab", 2))
+        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 3), ("c", 4))
+        self.assertTupleEqual(p._parse_braces_alternative("ab{c,d}", 5), ("d", 6))
+
+    def test_parse_fixed_section(self):
+        # fixed_section <- (!("{" / "}") .)+
+        self.assertTupleEqual(p._parse_fixed_section("", 0), ("", 0))
+        self.assertTupleEqual(p._parse_fixed_section("ab{c,d}", 0), ("ab", 2))
+        self.assertRaises(p.PatternParsingError, p._parse_fixed_section, "c,d}", 0)
+
     def test_parse_pattern(self):
+        cfg = Config()
         # pattern <- (any_segments / fixed_segment)*
         self.assertEqual(
-            p._parse_pattern("?a[bc]/**/*.{def,ghi}"),
+            p._parse_pattern(cfg, "?a[bc]/**/*.def"),
             join_matchers(
                 m.AnyCharacter(),
                 m.FixedName("a"),
@@ -25,7 +74,7 @@ class ParseTests(TestCase):
                 m.AnySegments(),
                 m.AnyName(),
                 m.FixedName("."),
-                m.OneOf((m.FixedName("def"), m.FixedName("ghi"))),
+                m.FixedName("def"),
                 m.EndOfSegment(),
                 m.EndOfPath(),
             ),
@@ -40,7 +89,7 @@ class ParseTests(TestCase):
     def test_parse_fixed_segment(self):
         # fixed_segment <- name_part+ (SEP / EOS)
         self.assertTupleEqual(
-            p._parse_fixed_segment("?a[bc]/*.{def,ghi}", 0),
+            p._parse_fixed_segment("?a[bc]/*.def", 0),
             (
                 join_matchers(
                     m.AnyCharacter(),
@@ -52,15 +101,14 @@ class ParseTests(TestCase):
             ),
         )
         self.assertTupleEqual(
-            p._parse_fixed_segment("?a[bc]/*.{def,ghi}", 7),
+            p._parse_fixed_segment("?a[bc]/*.def", 7),
             (
                 join_matchers(
                     m.AnyName(),
-                    m.FixedName("."),
-                    m.OneOf((m.FixedName("def"), m.FixedName("ghi"))),
+                    m.FixedName(".def"),
                     m.EndOfSegment(),
                 ),
-                18,
+                12,
             ),
         )
 
@@ -82,8 +130,8 @@ class ParseTests(TestCase):
             p._parse_name_part("?a[bc],*{def,ghi}", 7), (m.AnyName(), 8)
         )
         self.assertTupleEqual(
-            p._parse_name_part("?a[bc],*{def,ghi}", 8),
-            (m.OneOf((m.FixedName("def"), m.FixedName("ghi"))), 17),
+            p._parse_name_part("?a[bc],*def", 8),
+            (m.FixedName("def"), 17),
         )
 
     def test_parse_any_name(self):
@@ -92,56 +140,6 @@ class ParseTests(TestCase):
         self.assertTupleEqual(p._parse_any_name("a*", 1), (m.AnyName(), 2))
         self.assertTupleEqual(p._parse_any_name("a***a", 1), (m.AnyName(), 4))
 
-    def test_parse_one_of(self):
-        # one_of = "{" simple_name_part+ ("," simple_name_part+)* "}"
-        self.assertTupleEqual(p._parse_one_of("", 0), (None, 0))
-        self.assertTupleEqual(p._parse_one_of("abc,def}", 0), (None, 0))
-        self.assertTupleEqual(p._parse_one_of("{abc,def", 0), (None, 0))
-        self.assertTupleEqual(
-            p._parse_one_of("{abc,def}", 0),
-            (m.OneOf((m.FixedName("abc"), m.FixedName("def"))), 9),
-        )
-        self.assertTupleEqual(
-            p._parse_one_of("{a[bc],d?f,ghi}", 0),
-            (
-                m.OneOf(
-                    (
-                        join_matchers(m.FixedName("a"), m.CharacterSet("bc", False)),
-                        join_matchers(
-                            m.FixedName("d"), m.AnyCharacter(), m.FixedName("f")
-                        ),
-                        m.FixedName("ghi"),
-                    )
-                ),
-                15,
-            ),
-        )
-        self.assertRaises(PatternParsingError, p._parse_one_of, "{abc{def}", 0)
-        self.assertTupleEqual(
-            p._parse_one_of("{abc{def}", 4), (m.OneOf((m.FixedName("def"),)), 9)
-        )
-        self.assertTupleEqual(
-            p._parse_one_of("{abc}def}", 0), (m.OneOf((m.FixedName("abc"),)), 5)
-        )
-        self.assertTupleEqual(
-            p._parse_one_of(os.path.join("{abc", "def}"), 0),
-            (None, 0),
-        )
-        self.assertTupleEqual(p._parse_one_of("{,def", 0), (None, 0))
-        self.assertRaises(PatternParsingError, p._parse_one_of, "{,def}", 0)
-
-    def test_parse_one_of_choice(self):
-        # one_of_choice = simple_name_part+
-        self.assertTupleEqual(
-            p._parse_one_of_choice("?a[bc],def", 0),
-            (
-                join_matchers(
-                    m.AnyCharacter(), m.FixedName("a"), m.CharacterSet("bc", False)
-                ),
-                6,
-            ),
-        )
-
     def test_parse_simple_name_part(self):
         # simple_name_part = any_character / character_set / fixed_name
         self.assertTupleEqual(
@@ -169,11 +167,11 @@ class ParseTests(TestCase):
             p._parse_character_set("[!abcdef]", 0), (m.CharacterSet("abcdef", True), 9)
         )
         self.assertTupleEqual(p._parse_character_set("[abcdef]", 3), (None, 3))
-        self.assertRaises(PatternParsingError, p._parse_character_set, "[abc[def]", 0)
+        self.assertRaises(p.PatternParsingError, p._parse_character_set, "[abc[def]", 0)
         self.assertTupleEqual(
             p._parse_character_set("[abc[def]", 4), (m.CharacterSet("def", False), 9)
         )
-        self.assertRaises(PatternParsingError, p._parse_character_set, "[abc!def]", 0)
+        self.assertRaises(p.PatternParsingError, p._parse_character_set, "[abc!def]", 0)
         self.assertTupleEqual(
             p._parse_character_set("[abc]def]", 0), (m.CharacterSet("abc", False), 5)
         )