dymokomi/luce-prism
Source of release 0.6.1
0.6.1 / tests / compatibility / layers.lucb
from luce_prism import prism
import interop
import strings
struct Case:
var name: str
var base: str
var layer: str
var expected: str
func parse(body: str) -> interop.Reference[prism.Document]!:
let source = try strings.join(["#prisma 4.0\n", body], "")
defer strings.release(source)
return try prism.Document.parse(source)
func verify(item: Case) -> !:
let base = try parse(item.base)
defer base.release()
let layer = try parse(item.layer)
defer layer.release()
let expected = try parse(item.expected)
defer expected.release()
let before = try base.value().copy()
defer before.release()
let output = try base.value().overlay(layer)
defer output.release()
if not (try output.value().equals(expected)):
print(item.name)
assert(try output.value().equals(expected))
assert(try base.value().equals(before))
for encoding in [prism.Encoding.text, prism.Encoding.binary, prism.Encoding.package]:
let encoded = try layer.value().encode(encoding)
defer encoded.release()
let restored = try prism.Document.decode(encoded.value().bytes())
defer restored.release()
assert(try restored.value().equals(layer))
let applied = try base.value().overlay(restored)
defer applied.release()
assert(try applied.value().equals(expected))
pub func run() -> !:
let base = "def object \"bolt\" { float radius = 0.5 float3 albedo = (1,1,1) } def object \"nut\" { float radius = 0.3 }"
let changed = "def object \"bolt\" { float radius = 0.9 float3 albedo = (1,1,1) } def object \"nut\" { float radius = 0.3 }"
let wired = "def material \"mat\" { float out = 1 } def object \"bolt\" { float in = 0 connect in = </mat.out> }"
let cases = [
Case("overlay_overrides_a_property_keeps_the_rest", base, "def object \"bolt\" { float radius = 0.9 }", changed),
Case("overlay_adds_a_new_element", base, "def object \"washer\" { float radius = 0.25 }", "def object \"bolt\" { float radius = 0.5 float3 albedo = (1,1,1) } def object \"nut\" { float radius = 0.3 } def object \"washer\" { float radius = 0.25 }"),
Case("overlay_preserves_a_reference_it_does_not_mention", "def object \"car\" { reference \"car.prisma\" float3 color = (1,0,0) }", "over object \"car\" { float3 color = (0,0,1) }", "def object \"car\" { reference \"car.prisma\" float3 color = (0,0,1) }"),
Case("overlay_connection_replaces_into_same_target", "def node \"a\" {} def node \"b\" {} def node \"c\" {} connect </c.in> = </a.out>", "connect </c.in> = </b.out>", "def node \"a\" {} def node \"b\" {} def node \"c\" {} connect </c.in> = </b.out>"),
Case("commit_is_overlay_then_keep_base_shape", base, "over object \"bolt\" { float radius = 0.9 }", changed),
Case("over_patches_existing_path", base, "over object \"bolt\" { float radius = 0.9 }", changed),
Case("over_on_missing_path_is_skipped_not_orphaned", base, "over object \"ghost\" { float radius = 1 }", base),
Case("def_on_missing_path_adds", "def object \"bolt\" {}", "def object \"washer\" {}", "def object \"bolt\" {} def object \"washer\" {}"),
Case("delete_removes_element_and_its_connections", wired, "delete \"/bolt\"", "def material \"mat\" { float out = 1 }"),
Case("delete_removes_a_whole_subtree", "def group \"g\" { def object \"a\" {} def object \"b\" {} }", "delete \"/g\"", ""),
Case("delete_of_absent_path_is_a_noop", base, "delete \"/nope\"", base),
Case("overlay_file_with_over_and_delete_round_trips", base, "over object \"bolt\" { float radius = 0.9 } delete \"/nut\"", "def object \"bolt\" { float radius = 0.9 float3 albedo = (1,1,1) }"),
Case("normal_document_has_no_override_or_deletions", base, "", base),
Case("overlay_disconnect_removes_a_wire_keeps_endpoints", wired, "disconnect \"/bolt.in\"", "def material \"mat\" { float out = 1 } def object \"bolt\" { float in = 0 }"),
Case("disconnect_tombstone_round_trips", "def node \"a\" {}", "disconnect \"/a.in\"", "def node \"a\" {}"),
Case("disconnect_of_an_unconnected_target_is_a_noop", wired, "disconnect \"/mat.out\"", wired),
Case("overlay_prunes_a_connection_left_dangling", "def object \"a\" {} def object \"b\" {}", "delete \"/b\" connect </b.in> = </a.out>", "def object \"a\" {}"),
Case("connection_equality_is_order_insensitive", "def node \"a\" {} def node \"b\" {} def node \"c\" {} connect </c.in> = </a.out> connect </b.in> = </a.out>", "", "def node \"a\" {} def node \"b\" {} def node \"c\" {} connect </b.in> = </a.out> connect </c.in> = </a.out>")
]
for item in cases:
try verify(item)
try overlay_stacks_later_wins()
try delete_then_readd_in_layers()
try sparse_layer_cases()
print("PASS 20 legacy overlay cases, layer round trips, and sparse layer map")
func overlay_stacks_later_wins() -> !:
let base = try parse("def object \"bolt\" { float radius = 0.5 }")
defer base.release()
let a = try parse("over object \"bolt\" { float radius = 0.7 }")
defer a.release()
let b = try parse("over object \"bolt\" { float radius = 0.2 }")
defer b.release()
let expected = try parse("def object \"bolt\" { float radius = 0.2 }")
defer expected.release()
var stack = try prism.LayerStack(base)
defer stack.close()
try stack.push(a)
try stack.push(b)
let output = try stack.resolve()
defer output.release()
assert(try output.value().equals(expected))
try stack.compact(1)
assert(stack.count() == 1)
let compacted = try stack.resolve()
defer compacted.release()
assert(try compacted.value().equals(expected))
try stack.compact(0)
let collapsed = try stack.base()
defer collapsed.release()
assert(try collapsed.value().equals(expected))
func sparse_layer_cases() -> !:
let users = try parse("def directory \"users\" { def directory \"bob\" {} }")
defer users.release()
let add_alice = try parse("def directory \"users\" { def directory \"alice\" {} }")
defer add_alice.release()
let alice_layer = try prism.layer_from(add_alice)
defer alice_layer.release()
assert(try prism.layer_has_child(users, alice_layer, "/users", "/users/alice"))
assert(try prism.layer_visible(users, alice_layer, "/users/alice"))
let order_doc = try parse("reorder \"/users\" = [\"/users/bob\"]")
defer order_doc.release()
let order_layer = try prism.layer_from(order_doc)
defer order_layer.release()
assert(try prism.layer_has_child2(users, alice_layer, order_layer, "/users", "/users/alice"))
assert(try prism.layer_has_child2(users, alice_layer, order_layer, "/users", "/users/bob"))
let tree = try parse("def group \"a\" { def object \"b\" { float v = 1 } }")
defer tree.release()
let delete_a = try parse("delete \"/a\"")
defer delete_a.release()
let delete_layer = try prism.layer_from(delete_a)
defer delete_layer.release()
assert(not (try prism.layer_visible(tree, delete_layer, "/a")))
assert(not (try prism.layer_visible(tree, delete_layer, "/a/b")))
assert(not (try prism.layer_has_child(tree, delete_layer, "/a", "/a/b")))
assert(not (try prism.layer_has_property(tree, delete_layer, "/a", "v")))
let set_v = try parse("over object \"a\" { float v = 2 }")
defer set_v.release()
let set_layer = try prism.layer_from(set_v)
defer set_layer.release()
assert(try prism.layer_has_property(tree, set_layer, "/a", "v"))
let ghost = try parse("over object \"ghost\" { float radius = 1 }")
defer ghost.release()
let ghost_layer = try prism.layer_from(ghost)
defer ghost_layer.release()
assert(not (try prism.layer_visible(tree, ghost_layer, "/ghost")))
let orphan = try prism.make_layer()
defer orphan.release()
try prism.layer_put_element(orphan, "/a/b")
assert(not (try prism.layer_visible2(tree, delete_layer, orphan, "/a/b")))
let combined = try tree.value().overlay(delete_a)
defer combined.release()
assert(not combined.value().contains("/a"))
assert(not combined.value().contains("/a/b"))
assert(combined.value().child_count("/a") == 0)
let patched = try tree.value().overlay(set_v)
defer patched.release()
let radius = try patched.value().get("/a", "v")
defer radius.release()
assert(try radius.value().number_at() == 2.0)
assert(tree.value().contains("/a/b"))
let expected = try patched.value().materialize()
defer expected.release()
try patched.value().bake()
assert(try patched.value().equals(expected))
let baked = try patched.value().get("/a", "v")
defer baked.release()
assert(try baked.value().number_at() == 2.0)
func delete_then_readd_in_layers() -> !:
let base = try parse("def object \"bolt\" { float radius = 0.5 float3 albedo = (1,1,1) }")
defer base.release()
let a = try parse("delete \"/bolt\"")
defer a.release()
let b = try parse("def object \"bolt\" { float radius = 1.5 }")
defer b.release()
let expected = try parse("def object \"bolt\" { float radius = 1.5 }")
defer expected.release()
var stack = try prism.LayerStack(base)
defer stack.close()
try stack.push(a)
try stack.push(b)
let output = try stack.resolve()
defer output.release()
assert(try output.value().equals(expected))