Stop instantiating character ranges

greenery/charclass_test.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import pytest
-
 from .charclass import (
     DIGIT,
     DOT,
@@ -12,8 +10,49 @@
     SPACECHAR,
     WORDCHAR,
     Charclass,
+    add_ord_range,
+    repartition,
 )
-from .fsm import ANYTHING_ELSE
+
+
+def test_add_ord_range_0() -> None:
+    assert add_ord_range([], (1, 2)) == [(1, 2)]
+
+
+def test_add_ord_range_1a() -> None:
+    assert add_ord_range(
+        [(1, 1), (3, 4), (10, 11), (13, 17)],
+        (7, 7),
+    ) == [(1, 1), (3, 4), (7, 7), (10, 11), (13, 17)]
+
+
+def test_add_ord_range_1b() -> None:
+    assert add_ord_range([(5, 16)], (1, 1)) == [(1, 1), (5, 16)]
+    assert add_ord_range([(5, 16)], (1, 2)) == [(1, 2), (5, 16)]
+    assert add_ord_range([(5, 16)], (1, 3)) == [(1, 3), (5, 16)]
+    assert add_ord_range([(5, 16)], (1, 4)) == [(1, 16)]
+    assert add_ord_range([(5, 16)], (1, 5)) == [(1, 16)]
+    assert add_ord_range([(5, 16)], (1, 16)) == [(1, 16)]
+    assert add_ord_range([(5, 16)], (1, 17)) == [(1, 17)]
+    assert add_ord_range([(5, 16)], (1, 18)) == [(1, 18)]
+    assert add_ord_range([(5, 16)], (4, 4)) == [(4, 16)]
+    assert add_ord_range([(5, 16)], (5, 5)) == [(5, 16)]
+    assert add_ord_range([(5, 16)], (5, 18)) == [(5, 18)]
+    assert add_ord_range([(5, 16)], (7, 8)) == [(5, 16)]
+    assert add_ord_range([(5, 16)], (10, 20)) == [(5, 20)]
+    assert add_ord_range([(5, 16)], (16, 20)) == [(5, 20)]
+    assert add_ord_range([(5, 16)], (17, 20)) == [(5, 20)]
+    assert add_ord_range([(5, 16)], (18, 20)) == [(5, 16), (18, 20)]
+
+
+def test_add_ord_range_2() -> None:
+    assert add_ord_range([(1, 2), (11, 12)], (5, 6)) == [(1, 2), (5, 6), (11, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (3, 6)) == [(1, 6), (11, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (2, 6)) == [(1, 6), (11, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (5, 9)) == [(1, 2), (5, 9), (11, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (5, 10)) == [(1, 2), (5, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (-2, -1)) == [(-2, -1), (1, 2), (11, 12)]
+    assert add_ord_range([(1, 2), (11, 12)], (0, 20)) == [(0, 20)]
 
 
 def test_charclass_equality() -> None:
@@ -24,21 +63,22 @@ def test_charclass_equality() -> None:
 
 
 def test_charclass_ctor() -> None:
-    with pytest.raises(TypeError):
-        Charclass(frozenset({"a", ANYTHING_ELSE}))  # type: ignore
-
-    with pytest.raises(ValueError):
-        Charclass(frozenset({"a", "aa"}))
-
-    assert Charclass("ab") == Charclass(frozenset({"a", "b"}))
-
     assert not Charclass("ab").negated
     assert not Charclass("ab", negated=False).negated
     assert Charclass("ab", negated=True).negated
 
 
 def test_repr() -> None:
-    assert repr(~Charclass("a")) == "~Charclass('a')"
+    assert repr(~Charclass("a")) == "~Charclass((('a', 'a'),))"
+
+
+def test_issubset() -> None:
+    assert Charclass("a").issubset(Charclass("a"))
+    assert not Charclass("a").issubset(Charclass("b"))
+    assert Charclass("a").issubset(Charclass((("a", "b"),)))
+    assert Charclass("a").issubset(~Charclass("b"))
+    assert not (~Charclass("a")).issubset(Charclass("b"))
+    assert ~Charclass("a").issubset(DOT)
 
 
 def test_charclass_str() -> None:
@@ -84,15 +124,6 @@ def test_charclass_str() -> None:
     assert str(~Charclass("^")) == "[^\\^]"
 
 
-def test_charclass_fsm() -> None:
-    # "[^a]"
-    nota = (~Charclass("a")).to_fsm()
-    assert nota.alphabet == {"a", ANYTHING_ELSE}
-    assert nota.accepts("b")
-    assert nota.accepts(["b"])
-    assert nota.accepts([ANYTHING_ELSE])
-
-
 def test_charclass_negation() -> None:
     assert ~~Charclass("a") == Charclass("a")
     assert Charclass("a") == ~~Charclass("a")
@@ -103,24 +134,11 @@ def test_charclass_union() -> None:
     assert Charclass("ab") | Charclass("bc") == Charclass("abc")
     # [ab] ∪ [^bc] = [^c]
     assert Charclass("ab") | ~Charclass("bc") == ~Charclass("c")
-    # [^a] ∪ [bc] = [^a]
+    # [^ab] ∪ [bc] = [^a]
     assert ~Charclass("ab") | Charclass("bc") == ~Charclass("a")
     # [^ab] ∪ [^bc] = [^b]
     assert ~Charclass("ab") | ~Charclass("bc") == ~Charclass("b")
 
-    assert Charclass.union() == NULLCHARCLASS
-
-    assert Charclass.union(
-        Charclass("ab"),
-        Charclass("a"),
-        Charclass("cd"),
-    ) == Charclass("abcd")
-
-    assert Charclass.union(
-        Charclass("ab"),
-        ~Charclass("abc"),
-    ) == ~Charclass("c")
-
 
 def test_charclass_intersection() -> None:
     # [ab] ∩ [bc] = [b]
@@ -132,15 +150,139 @@ def test_charclass_intersection() -> None:
     # [^ab] ∩ [^bc] = [^abc]
     assert ~Charclass("ab") & ~Charclass("bc") == ~Charclass("abc")
 
-    assert Charclass.intersection(
-        Charclass("ab"),
-        Charclass("bcd"),
-        Charclass("abcde"),
-    ) == Charclass("b")
-
-    assert Charclass.intersection() == ~NULLCHARCLASS
+    assert (Charclass("ab") & Charclass("bcd") & Charclass("abcde")) == Charclass("b")
 
 
 def test_empty() -> None:
     assert NULLCHARCLASS.empty()
     assert not DOT.empty()
+
+
+def test_repartition_elementary() -> None:
+    assert repartition([Charclass("a")]) == {
+        Charclass("a"): [Charclass("a")],
+    }
+
+
+def test_repartition_elementary_2() -> None:
+    assert repartition([Charclass("a"), ~Charclass("a")]) == {
+        Charclass("a"): [Charclass("a")],
+        ~Charclass("a"): [~Charclass("a")],
+    }
+
+
+def test_repartition_basic() -> None:
+    assert repartition([Charclass("a"), Charclass("abc")]) == {
+        Charclass("a"): [
+            Charclass("a"),
+        ],
+        Charclass("abc"): [
+            Charclass("a"),
+            Charclass("bc"),
+        ],
+    }
+
+
+def test_repartition_negation() -> None:
+    assert repartition([Charclass("ab"), Charclass("a"), ~Charclass("ab")]) == {
+        Charclass("ab"): [
+            Charclass("a"),
+            Charclass("b"),
+        ],
+        Charclass("a"): [
+            Charclass("a"),
+        ],
+        ~Charclass("ab"): [
+            ~Charclass("ab"),
+        ],
+    }
+
+
+def test_repartition_negation_2() -> None:
+    assert repartition([Charclass("ab"), Charclass("abc"), ~Charclass("ab")]) == {
+        Charclass("ab"): [
+            Charclass("ab"),
+        ],
+        Charclass("abc"): [
+            Charclass("ab"),
+            Charclass("c"),
+        ],
+        ~Charclass("ab"): [
+            ~Charclass("abc"),
+            Charclass("c"),
+        ],
+    }
+    assert repartition(
+        [
+            ~Charclass("a"),
+            ~Charclass("ab"),
+            ~Charclass("abc"),
+        ]
+    ) == {
+        ~Charclass("a"): [
+            ~Charclass("abc"),
+            Charclass("b"),
+            Charclass("c"),
+        ],
+        ~Charclass("ab"): [
+            ~Charclass("abc"),
+            Charclass("c"),
+        ],
+        ~Charclass("abc"): [
+            ~Charclass("abc"),
+        ],
+    }
+
+
+def test_repartition_advanced() -> None:
+    assert repartition(
+        [
+            Charclass("a"),
+            Charclass("bcdef"),
+            ~Charclass("abcdef"),
+            Charclass("abcd"),
+            ~Charclass("abcd"),
+        ]
+    ) == {
+        Charclass("a"): [Charclass("a")],
+        Charclass("bcdef"): [
+            Charclass("bcd"),
+            Charclass("ef"),
+        ],
+        ~Charclass("abcdef"): [
+            ~Charclass("abcdef"),
+        ],
+        Charclass("abcd"): [
+            Charclass("a"),
+            Charclass("bcd"),
+        ],
+        ~Charclass("abcd"): [
+            ~Charclass("abcdef"),
+            Charclass("ef"),
+        ],
+    }
+
+
+def test_repartition_advanced_2() -> None:
+    assert repartition([WORDCHAR, DIGIT, DOT, NONDIGITCHAR, NULLCHARCLASS]) == {
+        WORDCHAR: [
+            DIGIT,
+            Charclass("ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"),
+        ],
+        DIGIT: [DIGIT],
+        DOT: [
+            ~Charclass((("0", "z"),)),
+            DIGIT,
+            Charclass(((":", "@"), ("[", "^"), ("`", "`"))),
+            Charclass("ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"),
+        ],
+        NONDIGITCHAR: [
+            ~Charclass((("0", "z"),)),
+            Charclass(((":", "@"), ("[", "^"), ("`", "`"))),
+            Charclass("ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"),
+        ],
+        NULLCHARCLASS: [
+            # Yup, there's nothing here!
+            # This should be impossible or at least cause no problems in practice
+        ],
+    }