Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / composition / layers.lucb

## Sparse layers, deterministic sibling ordering and exact authored diffs.
from model import DocumentData, Element
from animation import equal_properties
from comparison import equal_assets
from storage import Buffer, List, add_name, close_names, equal_names, find_pair, has_name, remove_pair, set_pair, text_copy
from path import element_path, is_descendant, parent_path
from types import limit_exceeded, max_depth, unsupported

func emit_order(source: const DocumentData*, output: DocumentData*, parent: str, depth: usize) -> !:
    if depth > max_depth:
        error(limit_exceeded, "Prism reorder nesting limit exceeded")
    var children = try source.children(parent)
    defer children.close()
    var emitted: List[Buffer]
    defer close_names(&emitted)
    for order in source.reorders.span():
        if order.parent.view() == parent:
            for child in order.children.span():
                let path = child.view()
                if source.contains(path) and parent_path(path) == parent and not has_name(&emitted, path):
                    try output.insert_copy(&source.elements.items[try source.require(path)])
                    try add_name(&emitted, path)
                    try emit_order(source, output, path, depth + 1)
    for path in children.span():
        if not has_name(&emitted, path):
            try output.insert_copy(&source.elements.items[try source.require(path)])
            try emit_order(source, output, path, depth + 1)

pub func rebuild_order(source: const DocumentData*) -> DocumentData!:
    var output = try source.copy()
    errdefer output.close()
    output.clear_elements()
    try emit_order(source, &output, "/", 0)
    for i in 0..<output.reorders.count:
        output.reorders.items[i].close()
    output.reorders.close()
    return output

pub func prune_connections(document: DocumentData*):
    var i = document.connections.count
    while i > 0:
        i -= 1
        let connection = &document.connections.items[i]
        if not document.contains(element_path(connection.key.view())) or not document.contains(element_path(connection.value.view())):
            connection.close()
            document.connections.remove(i)

pub func overlay(base: const DocumentData*, layers: const DocumentData[]) -> DocumentData!:
    var output = try base.copy()
    errdefer output.close()
    for layer in layers:
        for deletion in layer.deletions.span():
            if output.contains(deletion.view()):
                try output.remove(deletion.view())
        for disconnected in layer.disconnections.span():
            output.disconnect(disconnected.view())
        for element in layer.elements.span():
            if let index = output.find(element.path.view()):
                let authored = &output.elements.items[index]
                for prop in element.properties.span():
                    try authored.put_property(&prop)
                for meta in element.metadata.span():
                    try set_pair(&authored.metadata, meta.key.view(), meta.value.view())
                for removed in element.removed_properties.span():
                    authored.remove_property(removed.view())
                for removed in element.removed_metadata.span():
                    remove_pair(&authored.metadata, removed.view())
                if element.kind.used > 0:
                    try output.set_type(element.path.view(), element.kind.view())
            elif not element.override:
                try output.insert_copy(&element)
                output.elements.items[output.elements.count - 1].override = false
        for connection in layer.connections.span():
            try set_pair(&output.connections, connection.key.view(), connection.value.view())
        for asset in layer.assets.span():
            try output.set_asset(asset.path.view(), asset.bytes.bytes(), asset.mime.view())
        for order in layer.reorders.span():
            var children: List[str]
            defer children.close()
            for child in order.children.span():
                try children.push(child.view())
            try output.reorder(order.parent.view(), children.span())
    if output.reorders.count > 0:
        let ordered = try rebuild_order(&output)
        output.close()
        output = ordered
    prune_connections(&output)
    return output

pub func diff(base: const DocumentData*, target: const DocumentData*) -> DocumentData!:
    # Legacy layers have no asset-store delta records. Never return a diff that
    # looks successful while losing an attachment edit during event-log replay.
    if not equal_assets(base, target):
        error(unsupported, "legacy Prism diffs require unchanged package assets; use typed byte properties for editable media")
    var output = DocumentData()
    errdefer output.close()
    for element in base.elements.span():
        let path = element.path.view()
        if not target.contains(path):
            let parent = parent_path(path)
            if parent == "/" or target.contains(parent):
                try output.mark_deleted(path)
    for element in target.elements.span():
        let path = element.path.view()
        if let index = base.find(path):
            let before = &base.elements.items[index]
            var change = Element(override = true)
            defer change.close()
            change.path = try text_copy(path)
            var changed = false
            if before.kind.view() != element.kind.view():
                change.kind = try element.kind.copy()
                changed = change.kind.used > 0
            for prop in element.properties.span():
                let previous = before.property(prop.name.view())
                var different = true
                if let position = previous:
                    different = not equal_properties(&before.properties.items[position], &prop)
                if different:
                    try change.put_property(&prop)
                    changed = true
            for prop in before.properties.span():
                if element.property(prop.name.view()) == none:
                    try add_name(&change.removed_properties, prop.name.view())
                    changed = true
            for meta in element.metadata.span():
                let previous = find_pair(&before.metadata, meta.key.view())
                if previous == none or (previous else "") != meta.value.view():
                    try set_pair(&change.metadata, meta.key.view(), meta.value.view())
                    changed = true
            for meta in before.metadata.span():
                if find_pair(&element.metadata, meta.key.view()) == none:
                    try add_name(&change.removed_metadata, meta.key.view())
                    changed = true
            if changed:
                try output.insert_copy(&change)
        else:
            try output.insert_copy(&element)
            output.elements.items[output.elements.count - 1].override = false
    for connection in target.connections.span():
        let before = find_pair(&base.connections, connection.key.view())
        if before == none or (before else "") != connection.value.view():
            try set_pair(&output.connections, connection.key.view(), connection.value.view())
    for connection in base.connections.span():
        if find_pair(&target.connections, connection.key.view()) == none and target.contains(element_path(connection.key.view())):
            try output.mark_disconnected(connection.key.view())
    var parents: List[Buffer]
    defer close_names(&parents)
    try add_name(&parents, "/")
    for element in target.elements.span():
        try add_name(&parents, parent_path(element.path.view()))
    for parent in parents.span():
        var before = try base.children(parent.view())
        defer before.close()
        var after = try target.children(parent.view())
        defer after.close()
        var predicted: List[str]
        defer predicted.close()
        for child in before.span():
            if target.contains(child):
                try predicted.push(child)
        for child in after.span():
            if not base.contains(child):
                try predicted.push(child)
        var equal = predicted.count == after.count
        if equal:
            for i in 0..<after.count:
                if after.items[i] != predicted.items[i]:
                    equal = false
        if not equal:
            try output.reorder(parent.view(), after.span())
    return output