[Library] improve handling of dangling refs

masque/test/test_library.py

@@ -1,10 +1,12 @@
 import pytest
 from typing import cast, TYPE_CHECKING
+from numpy.testing import assert_allclose
 from ..library import Library, LazyLibrary
 from ..pattern import Pattern
 from ..error import LibraryError, PatternError
 from ..ports import Port
 from ..repetition import Grid
+from ..file.utils import preflight
 
 if TYPE_CHECKING:
     from ..shapes import Polygon
@@ -41,6 +43,79 @@ def test_library_dangling() -> None:
     assert lib.dangling_refs() == {"missing"}
 
 
+def test_library_dangling_graph_modes() -> None:
+    lib = Library()
+    lib["parent"] = Pattern()
+    lib["parent"].ref("missing")
+
+    with pytest.raises(LibraryError, match="Dangling refs found"):
+        lib.child_graph()
+    with pytest.raises(LibraryError, match="Dangling refs found"):
+        lib.parent_graph()
+    with pytest.raises(LibraryError, match="Dangling refs found"):
+        lib.child_order()
+
+    assert lib.child_graph(dangling="ignore") == {"parent": set()}
+    assert lib.parent_graph(dangling="ignore") == {"parent": set()}
+    assert lib.child_order(dangling="ignore") == ["parent"]
+
+    assert lib.child_graph(dangling="include") == {"parent": {"missing"}, "missing": set()}
+    assert lib.parent_graph(dangling="include") == {"parent": set(), "missing": {"parent"}}
+    assert lib.child_order(dangling="include") == ["missing", "parent"]
+
+
+def test_find_refs_with_dangling_modes() -> None:
+    lib = Library()
+    lib["target"] = Pattern()
+
+    mid = Pattern()
+    mid.ref("target", offset=(2, 0))
+    lib["mid"] = mid
+
+    top = Pattern()
+    top.ref("mid", offset=(5, 0))
+    top.ref("missing", offset=(9, 0))
+    lib["top"] = top
+
+    assert lib.find_refs_local("missing", dangling="ignore") == {}
+    assert lib.find_refs_global("missing", dangling="ignore") == {}
+
+    local_missing = lib.find_refs_local("missing", dangling="include")
+    assert set(local_missing) == {"top"}
+    assert_allclose(local_missing["top"][0], [[9, 0, 0, 0, 1]])
+
+    global_missing = lib.find_refs_global("missing", dangling="include")
+    assert_allclose(global_missing[("top", "missing")], [[9, 0, 0, 0, 1]])
+
+    with pytest.raises(LibraryError, match="missing"):
+        lib.find_refs_local("missing")
+    with pytest.raises(LibraryError, match="missing"):
+        lib.find_refs_global("missing")
+
+    global_target = lib.find_refs_global("target")
+    assert_allclose(global_target[("top", "mid", "target")], [[7, 0, 0, 0, 1]])
+
+
+def test_preflight_prune_empty_preserves_dangling_policy(caplog: pytest.LogCaptureFixture) -> None:
+    def make_lib() -> Library:
+        lib = Library()
+        lib["empty"] = Pattern()
+        lib["top"] = Pattern()
+        lib["top"].ref("missing")
+        return lib
+
+    caplog.set_level("WARNING")
+    warned = preflight(make_lib(), allow_dangling_refs=None, prune_empty_patterns=True)
+    assert "empty" not in warned
+    assert any("Dangling refs found" in record.message for record in caplog.records)
+
+    allowed = preflight(make_lib(), allow_dangling_refs=True, prune_empty_patterns=True)
+    assert "empty" not in allowed
+
+    with pytest.raises(LibraryError, match="Dangling refs found"):
+        preflight(make_lib(), allow_dangling_refs=False, prune_empty_patterns=True)
+
+
 def test_library_flatten() -> None:
     lib = Library()
     child = Pattern()