Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / document.lucb

## Public document ownership, authoring facade and explicit file I/O.
import memory
import interop
import strings
from luce_std import files
import c
import comparison
import composition.layers
import composition.delta
import authoring.names
import authoring.prefab
import logic.builders as logic_builders
import surface.math as surface_math
import surface.logic as surface_logic
import pattern as patterns
from logic.atoms import Atom, Atoms, RuleKind
from authoring.paths import Paths, own_paths
from path import is_descendant, parent_path
from model import DocumentData, Element, drop_data, hold_data, own_data
import tables
from serialization.binary import write_binary
from serialization.dispatch import read_document
from serialization.package import write_package
from serialization.text_writer import write_text
from storage import Blob, List, own_blob, text_copy
from types import HandleType, Encoding, Interpolation, invalid, missing, max_bytes
from value import Value, own_value
from animation import Property, Sample

pub struct Document:
    # Package implementation access. Not part of the stable consumer API.
    var data: DocumentData*
    var tables: tables.Tables*
    var tables_dirty: bool
    var extra: delta.Layer
    var layered: bool
    var generation: usize
    var open: bool

    pub func init() -> !:
        self.extra = delta.Layer()
        self.layered = false
        self.generation = 0
        let data = try new DocumentData() in memory.heap
        data.references.store(1, .relaxed)
        errdefer drop_data(data)
        self.data = data
        self.tables = try tables.empty_tables()
        self.tables_dirty = false
        self.open = true

    pub func revision() -> usize:
        return self.generation

    pub func is_layered() -> bool:
        return self.layered

    func writable() -> DocumentData*!:
        if self.data.references.load(.relaxed) == 1:
            return self.data
        var copy = try self.data.copy()
        errdefer copy.close()
        drop_data(self.data)
        let heap = try new DocumentData() in memory.heap
        heap.close()
        heap[0] = copy
        copy = DocumentData()
        heap.references.store(1, .relaxed)
        self.data = heap
        self.tables_dirty = true
        return self.data

    func ensure_tables() -> !:
        if not self.tables_dirty:
            return
        let built = try tables.from_data(self.data)
        tables.drop_tables(self.tables)
        self.tables = built
        self.tables_dirty = false

    pub func view_data() -> const DocumentData*:
        return self.data

    pub func copy() -> interop.Reference[Document]!:
        let copied = try own_document(try self.data.copy())
        if self.layered:
            let native = try copied.get()
            native.extra.close()
            native.extra = try self.extra.copy()
            native.layered = true
        return copied

    pub func extract(path: str) -> interop.Reference[Document]!:
        return try own_document(try prefab.extract(self.data, path))

    func replace_tables(next: DocumentData):
        self.data.close()
        self.data[0] = next
        self.data.references.store(1, .relaxed)
        self.tables_dirty = true

    pub func compile_math(name: str, expression: str) -> !:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        try surface_math.compile(&next, name, expression)
        self.replace_tables(next)
        next = DocumentData()

    pub func compile_logic(name: str, rule: str) -> !:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        try surface_logic.compile(&next, name, rule)
        self.replace_tables(next)
        next = DocumentData()

    pub func add_fact(name: str, head: interop.Reference[Atom]) -> !:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        try logic_builders.add_fact(&next, name, (try head.get()).view_data())
        self.replace_tables(next)
        next = DocumentData()

    pub func add_rule(name: str, kind: RuleKind, head: interop.Reference[Atom], body: interop.Reference[Atoms]) -> !:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        try logic_builders.add_rule(&next, name, kind, (try head.get()).view_data(), (try body.get()).view_data())
        self.replace_tables(next)
        next = DocumentData()

    pub func add_superiority(name: str, superior: str, inferior: str) -> !:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        try logic_builders.add_superiority(&next, name, superior, inferior)
        self.replace_tables(next)
        next = DocumentData()

    pub func instantiate(fragment: interop.Reference[Document], parent: str = "/") -> interop.Reference[Paths]!:
        self.generation += 1
        var next = try (try self.writable()).copy()
        errdefer next.close()
        let roots = try own_paths(try prefab.instantiate(&next, (try fragment.get()).view_data(), parent))
        self.replace_tables(next)
        next = DocumentData()
        return roots

    pub func children(parent: str = "/") -> interop.Reference[Paths]!:
        var paths = Paths()
        errdefer paths.close()
        for i in 0..<self.child_count(parent):
            try paths.append(self.child_at(parent, i) else error(invalid, "invalid Prism child index"))
        let owned = paths
        paths = Paths()
        return try own_paths(owned)

    pub func find(pattern: str) -> interop.Reference[Paths]!:
        var paths = Paths()
        errdefer paths.close()
        for element in self.data.elements.span():
            if patterns.matches(pattern, element.path.view()):
                try paths.append(element.path.view())
        let owned = paths
        paths = Paths()
        return try own_paths(owned)

    pub func has_property(path: str, name: str) -> bool:
        if self.layered:
            return delta.has_property(self.data, &self.extra, none, path, name)
        return self.data.has_property(path, name)

    pub func remove_property(path: str, name: str) -> !:
        self.generation += 1
        try (try self.writable()).remove_property(path, name)

    pub func remove_metadata(path: str, key: str) -> !:
        self.generation += 1
        try (try self.writable()).remove_metadata(path, key)

    pub func has_metadata(path: str, key: str) -> bool:
        if self.layered:
            return delta.has_metadata(self.data, &self.extra, none, path, key)
        return self.data.has_metadata(path, key)

    pub func metadata_count(path: str) -> usize!:
        return try self.data.metadata_count(path)

    pub func metadata_name(path: str, index: usize) -> str!:
        return try self.data.metadata_name(path, index)

    pub func set_type(path: str, name: str) -> !:
        self.generation += 1
        try (try self.writable()).set_type(path, name)

    pub func overlay(layer: interop.Reference[Document]) -> interop.Reference[Document]!:
        var attached = try delta.from_document((try layer.get()).view_data())
        errdefer attached.close()
        if self.layered:
            var merged = try delta.merge(&self.extra, &attached)
            attached.close()
            attached = merged
        try self.ensure_tables()
        hold_data(self.data)
        tables.hold_tables(self.tables)
        let native = new Document() in memory.heap catch failure:
            tables.drop_tables(self.tables)
            drop_data(self.data)
            error(failure.code, failure.message)
        let empty = native.data
        native.data = self.data
        drop_data(empty)
        tables.drop_tables(native.tables)
        native.tables = self.tables
        native.tables_dirty = false
        native.extra.close()
        native.extra = attached
        native.layered = true
        attached = delta.Layer()
        return try interop.Reference[Document].adopt(native, document_type, memory.heap)

    pub func bake() -> !:
        if not self.layered:
            return
        self.generation += 1
        if self.data.references.load(.relaxed) == 1:
            try delta.apply(self.data, &self.extra)
            self.tables_dirty = true
        else:
            try self.ensure_tables()
            let next = try tables.apply_cow(self.tables, &self.extra)
            errdefer tables.drop_tables(next)
            var rebuilt = try tables.to_data(next)
            errdefer rebuilt.close()
            let heap = try own_data(rebuilt)
            rebuilt = DocumentData()
            drop_data(self.data)
            self.data = heap
            tables.drop_tables(self.tables)
            self.tables = next
            self.tables_dirty = false
        self.extra.close()
        self.extra = delta.Layer()
        self.layered = false

    func snapshot_data() -> DocumentData!:
        if not self.layered:
            return try self.data.copy()
        var output = try self.data.copy()
        errdefer output.close()
        try delta.apply(&output, &self.extra)
        return output

    pub func materialize() -> interop.Reference[Document]!:
        return try own_document(try self.snapshot_data())

    pub func diff(target: interop.Reference[Document]) -> interop.Reference[Document]!:
        var left_owned = DocumentData()
        defer left_owned.close()
        var right_owned = DocumentData()
        defer right_owned.close()
        var left: const DocumentData* = self.data
        if self.layered:
            left_owned = try self.snapshot_data()
            left = &left_owned
        let other = try target.get()
        var right: const DocumentData* = other.data
        if other.layered:
            right_owned = try other.snapshot_data()
            right = &right_owned
        return try own_document(try layers.diff(left, right))

    pub func equals(other: interop.Reference[Document]) -> bool!:
        if not self.layered and not (try other.get()).layered:
            return comparison.equal_documents(self.data, (try other.get()).view_data())
        let left = try self.materialize()
        defer left.release()
        let right = try (try other.get()).materialize()
        defer right.release()
        return comparison.equal_documents((try left.get()).view_data(), (try right.get()).view_data())

    pub func contains(path: str) -> bool:
        if self.layered:
            return delta.visible(self.data, &self.extra, none, path)
        return self.data.contains(path)

    pub func element_id(path: str) -> usize?:
        return self.data.element_id(path)

    pub func path_for_id(identifier: usize) -> str?:
        return self.data.path_for_id(identifier)

    pub func child_count(parent: str = "/") -> usize:
        if self.layered:
            var kids = delta.children(self.data, &self.extra, none, parent) catch failure:
                return 0
            defer kids.close()
            return kids.count
        return self.data.child_count(parent)

    pub func child_at(parent: str, index: usize) -> str?:
        if self.layered:
            var kids = delta.children(self.data, &self.extra, none, parent) catch failure:
                return none
            defer kids.close()
            if index >= kids.count:
                return none
            return kids.items[index]
        return self.data.child_at(parent, index)

    pub func element_count() -> usize:
        return self.data.element_count()

    pub func path_at(index: usize) -> str!:
        return try self.data.path_at(index)

    pub func type_at(path: str) -> str!:
        if self.layered:
            if not delta.visible(self.data, &self.extra, none, path):
                error(missing, "Prism element does not exist")
            if let op = self.extra.get(path, delta.Cell.element):
                if op.type_name.used > 0:
                    return op.type_name.view()
            return try self.data.type_at(path)
        return try self.data.type_at(path)

    pub func add(path: str, type_name: str, override: bool = false) -> !:
        self.generation += 1
        if self.layered:
            var op = delta.Op(override = override)
            errdefer op.close()
            op.type_name = try text_copy(type_name)
            try self.extra.put(path, delta.Cell.element, "", op)
            return
        try (try self.writable()).add(path, type_name, override)

    pub func append(path: str, type_name: str, override: bool = false) -> str!:
        self.generation += 1
        let owned = try self.writable()
        var allocated = try names.unique_path(owned, path)
        defer allocated.close()
        try owned.insert(allocated.view(), type_name, override)
        return try owned.path_at(owned.element_count() - 1)

    pub func add_child(parent: str, type_name: str) -> str!:
        self.generation += 1
        let owned = try self.writable()
        var allocated = try names.anonymous_path(owned, parent)
        defer allocated.close()
        try owned.insert(allocated.view(), type_name)
        return try owned.path_at(owned.element_count() - 1)

    pub func move(path: str, destination: str) -> str!:
        self.generation += 1
        let owned = try self.writable()
        if not owned.contains(path) or is_descendant(parent_path(destination), path):
            return path
        let identifier = owned.element_id(path) else error(invalid, "missing Prism element")
        var allocated = try names.unique_path(owned, destination, path)
        defer allocated.close()
        try owned.rename(path, allocated.view())
        return owned.path_for_id(identifier) else error(invalid, "moved Prism element lost its identity")

    pub func set(path: str, name: str, value: interop.Reference[Value], type_name: str = "") -> !:
        self.generation += 1
        if self.layered:
            var op = delta.Op()
            errdefer op.close()
            op.value = try (try value.get()).view_data().copy()
            if type_name.length > 0:
                op.type_name = try text_copy(type_name)
            try self.extra.put(path, delta.Cell.property, name, op)
            return
        try (try self.writable()).set(path, name, value, type_name)

    pub func get(path: str, name: str) -> interop.Reference[Value]!:
        if self.layered:
            return try own_value(try delta.read_property(self.data, &self.extra, none, path, name))
        return try self.data.get(path, name)

    pub func property_count(path: str) -> usize!:
        return try self.data.property_count(path)

    pub func property_name(path: str, index: usize) -> str!:
        return try self.data.property_name(path, index)

    pub func set_metadata(path: str, key: str, value: str) -> !:
        self.generation += 1
        try (try self.writable()).set_metadata(path, key, value)

    pub func metadata(path: str, key: str) -> str!:
        if self.layered:
            return try delta.read_metadata(self.data, &self.extra, none, path, key)
        return try self.data.metadata(path, key)

    pub func connect(source: str, target: str) -> !:
        self.generation += 1
        try (try self.writable()).connect(source, target)

    pub func connection_count() -> usize:
        return self.data.connection_count()

    pub func incoming_at(target: str) -> str?:
        if self.layered:
            return delta.incoming(self.data, &self.extra, none, target)
        return self.data.incoming(target)

    pub func source(target: str) -> str!:
        return self.incoming_at(target) else error(missing, "Prism input is not connected")

    func assemble(path: str) -> Element!:
        if self.layered:
            return try delta.assemble(self.data, &self.extra, none, path)
        return try self.data.elements.items[try self.data.require(path)].copy()

    pub func intern_path(path: str) -> str?:
        if self.layered:
            return delta.intern_path(self.data, &self.extra, none, path)
        if let index = self.data.find(path):
            return self.data.elements.items[index].path.view()
        return none

    func walk_from(parent: str, out: List[str]*) -> !:
        if self.layered:
            var kids = try delta.children(self.data, &self.extra, none, parent)
            defer kids.close()
            for path in kids.span():
                try out.push(path)
                try self.walk_from(path, out)
            return
        let count = self.data.child_count(parent)
        for i in 0..<count:
            let path = self.data.child_at(parent, i) else continue
            try out.push(path)
            try self.walk_from(path, out)

    func walk_visible() -> List[str]!:
        var out: List[str]
        errdefer out.close()
        try self.walk_from("/", &out)
        return out

    pub func disconnect(target: str) -> !:
        self.generation += 1
        (try self.writable()).disconnect(target)

    pub func set_sample(path: str, name: str, time: f64, value: interop.Reference[Value], interpolation: Interpolation = Interpolation.linear) -> !:
        self.generation += 1
        try (try self.writable()).set_sample(path, name, time, value, interpolation)

    pub func animate(path: str, name: str, time: f64, value: interop.Reference[Value], interpolation: Interpolation = Interpolation.linear) -> !:
        self.generation += 1
        let owned = try self.writable()
        if owned.has_property(path, name):
            try owned.set_sample(path, name, time, value, interpolation)
            return
        var next = try owned.copy()
        errdefer next.close()
        try next.set(path, name, value)
        try next.set_sample(path, name, time, value, interpolation)
        self.replace_tables(next)
        next = DocumentData()

    pub func set_handles(path: str, name: str, time: f64, kind: HandleType, left: const f64[], right: const f64[]) -> !:
        self.generation += 1
        try (try self.writable()).set_handles(path, name, time, kind, left, right)

    pub func remove_sample(path: str, name: str, time: f64) -> !:
        self.generation += 1
        try (try self.writable()).remove_sample(path, name, time)

    pub func sample_count(path: str, name: str) -> usize!:
        return try self.data.sample_count(path, name)

    func property(path: str, name: str) -> const Property*!:
        let element = self.data.elements.items[try self.data.require(path)]
        let index = element.property(name) else error(invalid, "Prism property does not exist")
        return &element.properties.items[index]

    func key(path: str, name: str, index: usize) -> const Sample*!:
        let property = try self.property(path, name)
        if index >= property.samples.count:
            error(invalid, "Prism keyframe index is out of bounds")
        return &property.samples.items[index]

    pub func property_type_name(path: str, name: str) -> str!:
        return (try self.property(path, name)).type_name.view()

    pub func sample_time_at(path: str, name: str, index: usize) -> f64!:
        return (try self.key(path, name, index)).time

    pub func sample_interpolation_at(path: str, name: str, index: usize) -> Interpolation!:
        return (try self.key(path, name, index)).interpolation

    pub func sample_handle_at(path: str, name: str, index: usize) -> HandleType!:
        return (HandleType)(try self.key(path, name, index)).handle

    pub func sample_left_at(path: str, name: str, index: usize) -> const f64[]!:
        return (try self.key(path, name, index)).left.span()

    pub func sample_right_at(path: str, name: str, index: usize) -> const f64[]!:
        return (try self.key(path, name, index)).right.span()

    pub func sample_value_at(path: str, name: str, index: usize) -> interop.Reference[Value]!:
        return try own_value(try (try self.key(path, name, index)).value.copy())

    pub func resolve(path: str, name: str, time: f64 = 0.0) -> interop.Reference[Value]!:
        return try self.data.resolve(path, name, time)

    pub func eval(slot: str, time: f64 = 0.0) -> interop.Reference[Value]!:
        return try self.data.eval(slot, time)

    pub func mark_deleted(path: str) -> !:
        self.generation += 1
        try (try self.writable()).mark_deleted(path)

    pub func mark_disconnected(target: str) -> !:
        self.generation += 1
        try (try self.writable()).mark_disconnected(target)

    pub func mark_unset(path: str, name: str, metadata: bool = false) -> !:
        self.generation += 1
        try (try self.writable()).mark_unset(path, name, metadata)

    pub func reorder(parent: str, children: const str[]) -> !:
        self.generation += 1
        try (try self.writable()).reorder(parent, children)

    pub func connect_pattern(source: str, target_pattern: str) -> !:
        self.generation += 1
        try (try self.writable()).connect_pattern(source, target_pattern)

    pub func set_asset(path: str, bytes: const u8[], mime: str = "application/octet-stream") -> !:
        self.generation += 1
        try (try self.writable()).set_asset(path, bytes, mime)

    pub func rename(path: str, destination: str) -> !:
        self.generation += 1
        try (try self.writable()).rename(path, destination)

    pub func remove(path: str) -> !:
        self.generation += 1
        if self.layered:
            try self.extra.put(path, delta.Cell.element, "", delta.Op(deleted = true))
            return
        try (try self.writable()).remove(path)

    pub func asset_count() -> usize:
        return self.data.asset_count()

    pub func asset(path: str) -> interop.Reference[Blob]!:
        return try self.data.asset(path)

    pub func asset_mime(path: str) -> str!:
        return try self.data.asset_mime(path)

    pub func close():
        self.generation += 1
        self.extra.close()
        self.layered = false
        if not self.open:
            return
        self.open = false
        tables.drop_tables(self.tables)
        drop_data(self.data)

    pub func encode(encoding: Encoding = Encoding.binary, compressed: bool = false) -> interop.Reference[Blob]!:
        if self.layered:
            let flat = try self.materialize()
            defer flat.release()
            return try (try flat.get()).encode(encoding, compressed)
        if encoding == Encoding.package:
            return try own_blob(try write_package(self.data, compressed))
        if self.data.assets.count > 0:
            error(invalid, "use package encoding to preserve Prism assets")
        if encoding == Encoding.text:
            return try own_blob(try write_text(self.data))
        if encoding == Encoding.binary:
            return try own_blob(try write_binary(self.data, compressed))
        error(invalid, "choose a Prism encoding")

    pub func encode_package(text_scene: bool = false, compressed: bool = false) -> interop.Reference[Blob]!:
        if self.layered:
            let flat = try self.materialize()
            defer flat.release()
            return try (try flat.get()).encode_package(text_scene, compressed)
        return try own_blob(try write_package(self.data, compressed, text_scene))

    pub func remove_asset(path: str) -> !:
        self.generation += 1
        (try self.writable()).remove_asset(path)

    pub static func decode(bytes: const u8[]) -> interop.Reference[Document]!:
        let native = try new Document() in memory.heap
        read_document(bytes, native.data) catch failure:
            native.close()
            free(native) in memory.heap
            error(failure.code, failure.message)
        let built = tables.from_data(native.data) catch failure:
            native.close()
            free(native) in memory.heap
            error(failure.code, failure.message)
        tables.drop_tables(native.tables)
        native.tables = built
        native.tables_dirty = false
        return try interop.Reference[Document].adopt(native, document_type, memory.heap)

    pub static func parse(text: str) -> interop.Reference[Document]!:
        return try Document.decode(text.bytes)

    pub static func load(path: str) -> interop.Reference[Document]!:
        with memory.heap:
            let name = try strings.copy(path)
            defer strings.release(name)
            let bytes = try files.read((c.str)name, limit = max_bytes)
            defer bytes.release()
            return try Document.decode(bytes.value)

    pub func save(path: str, encoding: Encoding = Encoding.binary, compressed: bool = false) -> !:
        let output = try self.encode(encoding, compressed)
        defer output.release()
        with memory.heap:
            let name = try strings.copy(path)
            defer strings.release(name)
            try files.write_atomic((c.str)name, output.value().bytes(), synchronize = true)

pub let document_type = interop.Type[Document]("Prism document", Document.close, closeable = true)

pub func snapshot_document(native: const Document*) -> DocumentData!:
    return try native.snapshot_data()

pub func assemble_element(native: const Document*, path: str) -> Element!:
    return try native.assemble(path)

pub func walk_document(native: const Document*) -> List[str]!:
    return try native.walk_visible()

pub func own_document(data: DocumentData) -> interop.Reference[Document]!:
    var owned = data
    errdefer owned.close()
    let native = try new Document() in memory.heap
    native.data.close()
    native.data[0] = owned
    native.data.references.store(1, .relaxed)
    owned = DocumentData()
    let built = tables.from_data(native.data) catch failure:
        native.close()
        free(native) in memory.heap
        error(failure.code, failure.message)
    tables.drop_tables(native.tables)
    native.tables = built
    native.tables_dirty = false
    return try interop.Reference[Document].adopt(native, document_type, memory.heap)

pub func own_view(data: DocumentData*, extra: delta.Layer) -> interop.Reference[Document]!:
    var attached = extra
    errdefer attached.close()
    hold_data(data)
    let native = new Document() in memory.heap catch failure:
        drop_data(data)
        error(failure.code, failure.message)
    let empty = native.data
    native.data = data
    drop_data(empty)
    let built = tables.from_data(data) catch failure:
        native.close()
        free(native) in memory.heap
        error(failure.code, failure.message)
    tables.drop_tables(native.tables)
    native.tables = built
    native.tables_dirty = false
    if attached.count() > 0:
        native.extra.close()
        native.extra = attached
        native.layered = true
        attached = delta.Layer()
    return try interop.Reference[Document].adopt(native, document_type, memory.heap)