Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / tests / compatibility / references.lucb

from luce_prism import prism
import interop
import strings

func number(document: interop.Reference[prism.Document], path: str, name: str) -> f64!:
    let value = try document.value().get(path, name)
    defer value.release()
    return try value.value().number_at()

func pair(root: str, source: str, filename: str = "lib.prisma") -> interop.Reference[prism.Document]!:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let a = try prism.Document.parse(root)
    defer a.release()
    let b = try prism.Document.parse(source)
    defer b.release()
    try library.add("root.prisma", a)
    try library.add(filename, b)
    return try library.compose("root.prisma")

func compose_grafts_referenced_subtree() -> !:
    let output = try pair("#prisma 4.0\ndef group \"a\" { reference \"lib.prisma\" }", "#prisma 4.0\ndef object \"widget\" { float size = 10 def object \"handle\" { float len = 3 } }")
    defer output.release()
    assert(try number(output, "/a", "size") == 10.0)
    assert(try number(output, "/a/handle", "len") == 3.0)
    assert(not output.value().has_metadata("/a", "reference"))

func compose_local_opinions_win() -> !:
    let output = try pair("#prisma 4.0\ndef object \"a\" { float size = 99 reference \"lib.prisma\" }", "#prisma 4.0\ndef object \"widget\" { float size = 10 float3 color = (1,0,0) }")
    defer output.release()
    assert(try number(output, "/a", "size") == 99.0)
    assert(try number(output, "/a", "color") == 1.0)

func compose_reference_path_picks_subprim() -> !:
    let output = try pair("#prisma 4.0\ndef object \"x\" { reference \"lib.prisma\" \"/parts/bolt\" }", "#prisma 4.0\ndef group \"parts\" { def object \"bolt\" { int32 thread = 20 } }")
    defer output.release()
    assert(try number(output, "/x", "thread") == 20.0)

func compose_resolves_nested_references() -> !:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let leaf = try prism.Document.parse("#prisma 4.0\ndef object \"leaf\" { float value = 7 }")
    defer leaf.release()
    let middle = try prism.Document.parse("#prisma 4.0\ndef object \"mid\" { reference \"../leaf.prisma\" }")
    defer middle.release()
    let root = try prism.Document.parse("#prisma 4.0\ndef group \"m\" { reference \"sub/mid.prisma\" }")
    defer root.release()
    try library.add("leaf.prisma", leaf)
    try library.add("sub/mid.prisma", middle)
    try library.add("root.prisma", root)
    let output = try library.compose("root.prisma")
    defer output.release()
    assert(try number(output, "/m", "value") == 7.0)
    assert(root.value().has_metadata("/m", "reference"))
    assert(not root.value().has_property("/m", "value"))

func compose_detects_cycles() -> !:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let a = try prism.Document.parse("#prisma 4.0\ndef group \"a\" { reference \"b.prisma\" }")
    defer a.release()
    let b = try prism.Document.parse("#prisma 4.0\ndef group \"b\" { reference \"./a.prisma\" }")
    defer b.release()
    try library.add("a.prisma", a)
    try library.add("b.prisma", b)
    let result: interop.Reference[prism.Document]? = library.compose("a.prisma") catch failure:
        assert(failure.code == prism.invalid)
        recover none
    if let unexpected = result:
        unexpected.release()
        assert(false)

func compose_missing_reference_fails() -> !:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let root = try prism.Document.parse("#prisma 4.0\ndef group \"a\" { reference \"nope.prisma\" }")
    defer root.release()
    try library.add("root.prisma", root)
    let result: interop.Reference[prism.Document]? = library.compose("root.prisma") catch failure:
        assert(failure.code == prism.missing)
        recover none
    if let unexpected = result:
        unexpected.release()
        assert(false)

func compose_no_references_is_identity() -> !:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let root = try prism.Document.parse("#prisma 4.0\ndef object \"a\" { float x = 1 }")
    defer root.release()
    try library.add("root.prisma", root)
    let output = try library.compose("root.prisma")
    defer output.release()
    assert(try number(output, "/a", "x") == 1.0)
    assert(output.value().element_count() == 1)

func compose_file_resolves_relative_paths(directory: str) -> !:
    let root = try prism.Document.parse("#prisma 4.0\ndef group \"g\" { reference \"gear.prism\" }")
    defer root.release()
    let lib = try prism.Document.parse("#prisma 4.0\ndef object \"gear\" { int32 teeth = 24 }")
    defer lib.release()
    let filename = try strings.join([directory, "root.prisma"], "/")
    defer strings.release(filename)
    let target = try strings.join([directory, "gear.prism"], "/")
    defer strings.release(target)
    try root.value().save(filename, prism.Encoding.text)
    try lib.value().save(target, prism.Encoding.binary, true)
    let output = try prism.compose_file(filename)
    defer output.release()
    assert(try number(output, "/g", "teeth") == 24.0)
    assert(root.value().has_metadata("/g", "reference"))

func compose_diamond_dag_is_linear_not_exponential() -> !:
    var library = prism.ReferenceLibrary()
    defer library.close()
    let leaf = try prism.Document.parse("#prisma 4.0\ndef object \"leaf\" { int32 v = 42 }")
    defer leaf.release()
    let left = try prism.Document.parse("#prisma 4.0\ndef group \"left\" { reference \"leaf.prisma\" }")
    defer left.release()
    let right = try prism.Document.parse("#prisma 4.0\ndef group \"right\" { reference \"leaf.prisma\" }")
    defer right.release()
    let root = try prism.Document.parse("#prisma 4.0\ndef group \"l\" { reference \"left.prisma\" } def group \"r\" { reference \"right.prisma\" }")
    defer root.release()
    try library.add("leaf.prisma", leaf)
    try library.add("left.prisma", left)
    try library.add("right.prisma", right)
    try library.add("root.prisma", root)
    let output = try library.compose("root.prisma")
    defer output.release()
    assert(try number(output, "/l", "v") == 42.0)
    assert(try number(output, "/r", "v") == 42.0)

func compose_local_subtree_wins_wholesale() -> !:
    let output = try pair("#prisma 4.0\ndef object \"a\" { reference \"lib.prisma\" def object \"handle\" { float len = 99 } }", "#prisma 4.0\ndef object \"widget\" { def object \"handle\" { float len = 3 def object \"grip\" { bool soft = true } } }")
    defer output.release()
    assert(try number(output, "/a/handle", "len") == 99.0)
    assert(not output.value().contains("/a/handle/grip"))

func reference_wildcard_grafts_matches_as_children() -> !:
    let output = try pair("#prisma 4.0\ndef group \"hardware\" { reference \"lib.prisma\" \"/parts/*\" }", "#prisma 4.0\ndef group \"parts\" { def object \"bolt\" { float len = 3 } def object \"nut\" { float len = 1 } def object \"washer\" { float len = 0.2 } }")
    defer output.release()
    assert(output.value().contains("/hardware/bolt"))
    assert(output.value().contains("/hardware/nut"))
    assert(output.value().contains("/hardware/washer"))
    assert(not output.value().contains("/hardware/parts"))
    assert(try number(output, "/hardware/bolt", "len") == 3.0)
    assert(not output.value().has_metadata("/hardware", "referencePath"))

func reference_wildcard_brings_subtrees_and_scaffolding() -> !:
    let output = try pair("#prisma 4.0\ndef group \"scene\" { reference \"lib.prisma\" \"/rig/**/camera\" }", "#prisma 4.0\ndef group \"rig\" { def group \"arm\" { def camera \"camera\" { float fov = 50 } } }")
    defer output.release()
    assert(output.value().contains("/scene/arm"))
    assert(try number(output, "/scene/arm/camera", "fov") == 50.0)
    assert(not output.value().contains("/scene/rig"))

func reference_wildcard_carries_internal_connections() -> !:
    let output = try pair("#prisma 4.0\ndef group \"hw\" { reference \"lib.prisma\" \"/parts/*\" }", "#prisma 4.0\ndef group \"parts\" { def material \"mat\" { float3 out = (0,1,0) } def object \"bolt\" { float3 albedo = (1,1,1) connect albedo = </parts/mat.out> } }")
    defer output.release()
    assert(try output.value().source("/hw/bolt.albedo") == "/hw/mat.out")

func seed_photos(store: prism.Store*) -> !:
    try store.mount("media.prism")
    let root = try store.begin()
    defer root.release()
    try root.value().add("/users", "directory")
    try root.value().add("/users/alice", "directory")
    try root.value().add("/users/alice/photos", "link")
    try root.value().set_metadata("/users/alice/photos", "reference", "media.prism")
    _ = try root.value().commit()
    let media = try store.begin_identity("media.prism")
    defer media.release()
    try media.value().add("/vacation", "file")
    let payload = try prism.Value.array(prism.DType.uint8, [4], b"JPEG")
    defer payload.release()
    try media.value().set("/vacation", "bytes", payload)
    _ = try media.value().commit()

func lookup_photos_without_reference_path_is_mount_root() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    let look = try store.lookup("/users/alice/photos", true)
    defer look.release()
    assert(look.value().identity() == "media.prism")
    assert(look.value().path() == "/")
    assert(look.value().kind() == prism.LookKind.directory)
    let slash = try store.lookup("//users//alice/photos")
    defer slash.release()
    assert(slash.value().identity() == "media.prism")
    assert(slash.value().path() == "/")
    assert(try store.kind("/users/alice/photos") == prism.LookKind.directory)

func read_vacation_bytes_without_grafting() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    let got = try store.read("/users/alice/photos/vacation")
    defer got.release()
    let expected = try prism.Value.array(prism.DType.uint8, [4], b"JPEG")
    defer expected.release()
    assert(try got.value().equals(expected))
    let snap = try store.snapshot()
    defer snap.release()
    assert(not try snap.value().contains("/users/alice/photos/vacation"))
    assert(try snap.value().metadata("/users/alice/photos", "reference") == "media.prism")
    let grafted: interop.Reference[prism.Value]? = snap.value().get("/users/alice/photos/vacation", "bytes") catch failure:
        assert(failure.code == prism.missing)
        recover none
    if let unexpected = grafted:
        unexpected.release()
        assert(false)
    let look = try store.lookup("/users/alice/photos/vacation", true)
    defer look.release()
    assert(look.value().identity() == "media.prism")
    assert(look.value().path() == "/vacation")
    assert(look.value().kind() == prism.LookKind.file)

func session_get_does_not_lookup() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    let snap = try store.snapshot()
    defer snap.release()
    assert(try snap.value().type_at("/users/alice/photos") == "link")
    assert(try snap.value().metadata("/users/alice/photos", "reference") == "media.prism")
    assert(not try snap.value().contains("/vacation"))

func lookup_follow_false_stops_on_terminal_link() -> !:
    var store = try prism.Store()
    defer store.close()
    try seed_photos(&store)
    let look = try store.lookup("/users/alice/photos", false)
    defer look.release()
    assert(look.value().identity() == "root")
    assert(look.value().path() == "/users/alice/photos")
    assert(look.value().kind() == prism.LookKind.link)
    let nested = try store.lookup("/users/alice/photos/vacation", false)
    defer nested.release()
    assert(nested.value().identity() == "media.prism")
    assert(nested.value().path() == "/vacation")
    assert(nested.value().kind() == prism.LookKind.file)

func lookup_detects_identity_cycle() -> !:
    var store = try prism.Store()
    defer store.close()
    try store.mount("media.prism")
    let root = try store.begin()
    defer root.release()
    try root.value().add("/loop", "link")
    try root.value().set_metadata("/loop", "reference", "media.prism")
    _ = try root.value().commit()
    let media = try store.begin_identity("media.prism")
    defer media.release()
    try media.value().add("/back", "link")
    try media.value().set_metadata("/back", "reference", "root")
    _ = try media.value().commit()
    var cycled = false
    let result: interop.Reference[prism.Look]? = store.lookup("/loop/back/x") catch failure:
        assert(failure.code == prism.invalid)
        cycled = true
        recover none
    if let unexpected = result:
        unexpected.release()
        assert(false)
    assert(cycled)

func lookup_resolves_host_name_metadata() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/users", "directory")
    try tx.value().add("/users/alice", "directory")
    try tx.value().add("/users/alice/[0]", "file")
    try tx.value().set_metadata("/users/alice/[0]", "name", "notes.txt")
    let payload = try prism.Value.text("hi")
    defer payload.release()
    try tx.value().set("/users/alice/[0]", "text", payload)
    _ = try tx.value().commit()
    let look = try store.lookup("/users/alice/notes.txt")
    defer look.release()
    assert(look.value().identity() == "root")
    assert(look.value().path() == "/users/alice/[0]")
    assert(look.value().kind() == prism.LookKind.file)
    let got = try store.read("/users/alice/notes.txt")
    defer got.release()
    assert(try got.value().text_at() == "hi")

func lookup_through_non_directory_fails() -> !:
    var store = try prism.Store()
    defer store.close()
    let tx = try store.begin()
    defer tx.release()
    try tx.value().add("/notes", "file")
    _ = try tx.value().commit()
    var refused = false
    let result: interop.Reference[prism.Look]? = store.lookup("/notes/x") catch failure:
        assert(failure.code == prism.invalid)
        refused = true
        recover none
    if let unexpected = result:
        unexpected.release()
        assert(false)
    assert(refused)

func lookup_missing_is_not_an_error() -> !:
    var store = try prism.Store()
    defer store.close()
    let look = try store.lookup("/nope")
    defer look.release()
    assert(look.value().identity() == "root")
    assert(look.value().path() == "")
    assert(look.value().kind() == prism.LookKind.missing)
    assert(try store.kind("/nope") == prism.LookKind.missing)
    var absent = false
    let result: interop.Reference[prism.Value]? = store.read("/nope") catch failure:
        assert(failure.code == prism.missing)
        absent = true
        recover none
    if let unexpected = result:
        unexpected.release()
        assert(false)
    assert(absent)

pub func run(directory: str) -> !:
    try compose_grafts_referenced_subtree()
    try compose_local_opinions_win()
    try compose_reference_path_picks_subprim()
    try compose_resolves_nested_references()
    try compose_detects_cycles()
    try compose_missing_reference_fails()
    try compose_no_references_is_identity()
    try compose_file_resolves_relative_paths(directory)
    try compose_diamond_dag_is_linear_not_exponential()
    try compose_local_subtree_wins_wholesale()
    try reference_wildcard_grafts_matches_as_children()
    try reference_wildcard_brings_subtrees_and_scaffolding()
    try reference_wildcard_carries_internal_connections()
    try lookup_photos_without_reference_path_is_mount_root()
    try read_vacation_bytes_without_grafting()
    try session_get_does_not_lookup()
    try lookup_follow_false_stops_on_terminal_link()
    try lookup_detects_identity_cycle()
    try lookup_resolves_host_name_metadata()
    try lookup_through_non_directory_fails()
    try lookup_missing_is_not_an_error()
    print("PASS 13 legacy reference composition cases + namei")