Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / editor / projection.lucb

## Text remains authoritative while typing; failed parses retain the last good model.
import interop
import memory
import ownership
import codecs.api as codecs
from codecs.custom import CodecAdapter
from codecs.diagnostics import decode_diagnosed
from document import Document
from storage import Buffer, Blob, List, text_copy, copied, own_blob
from types import invalid

struct View:
    var name: Buffer
    var text: Buffer
    var canonical: Buffer

    func close():
        self.name.close()
        self.text.close()
        self.canonical.close()

func clear_views(views: List[View]*):
    for i in 0..<views.count:
        views.items[i].close()
    views.close()

func render(doc: interop.Reference[Document], codec: codecs.Codec, adapter: interop.Reference[CodecAdapter]?) -> Buffer!:
    let snapshot = try (try doc.get()).copy()
    defer snapshot.release()
    let output = try (try (adapter else error(invalid, "missing codec adapter")).get()).encode(snapshot) if adapter != none else try codecs.encode(snapshot, codec)
    defer output.release()
    return try copied((try output.get()).bytes())

pub struct TextProjection:
    var source: interop.Reference[Document]?
    var custom: interop.Reference[CodecAdapter]?
    var current: codecs.Codec
    var buffer: Buffer
    var message: Buffer
    var error_line: usize
    var error_column: usize
    var parsed: bool
    var views: List[View]
    var busy: bool
    var close_pending: bool

    pub func init() -> !:
        let doc = try Document.parse("#prisma 4.0\n")
        errdefer doc.release()
        let text = try render(doc, codecs.Codec.prisma, none)
        self.source = doc
        self.buffer = text
        self.current = codecs.Codec.prisma
        self.parsed = true
        self.custom = none
        self.message = Buffer()
        self.error_line = 0
        self.error_column = 0
        self.views = List[View]()
        self.busy = false
        self.close_pending = false

    pub func codec() -> codecs.Codec:
        return self.current

    pub func codec_name() -> str!:
        if let custom = self.custom:
            return (try custom.get()).name()
        return codecs.codec_name(self.current)

    pub func text() -> str!:
        return try str(self.buffer.bytes())

    pub func document() -> interop.Reference[Document]!:
        return try (try (self.source else error(invalid, "Prism text projection is closed")).get()).copy()

    pub func text_parses() -> bool:
        return self.parsed

    pub func error_message() -> str:
        return self.message.view()

    pub func line() -> usize:
        return self.error_line

    pub func column() -> usize:
        return self.error_column

    func enter() -> !:
        if self.busy:
            error(invalid, "Prism projection callback cannot mutate its active projection")
        self.busy = true

    func leave():
        self.busy = false
        if self.close_pending:
            self.close_pending = false
            self.close()

    func clear_error():
        self.message.close()
        self.error_line = 0
        self.error_column = 0
        self.parsed = true

    func replace(doc: interop.Reference[Document], text: Buffer):
        if let previous = self.source:
            previous.release()
        self.source = doc
        self.buffer.close()
        self.buffer = text
        self.clear_error()

    pub func set_document(document: interop.Reference[Document], view: codecs.Codec = codecs.Codec.auto) -> bool!:
        try self.enter()
        defer self.leave()
        let next = try (try document.get()).copy()
        errdefer next.release()
        var codec = self.current if view == codecs.Codec.auto else (codecs.Codec.prisma if view == codecs.Codec.prism else view)
        let adapter = self.custom if view == codecs.Codec.auto else none
        var represented = true
        var output = render(next, codec, adapter) catch failure:
            if failure.code == memory.exhausted:
                error(failure.code, failure.message)
            represented = false
            codec = codecs.Codec.prisma
            recover try render(next, codec, none)
        self.replace(next, output)
        if view != codecs.Codec.auto or not represented:
            if let previous = self.custom:
                previous.release()
            self.custom = none
        self.current = codec
        clear_views(&self.views)
        return represented

    func switch_view(codec: codecs.Codec, adapter: interop.Reference[CodecAdapter]?) -> bool!:
        let doc = self.source else error(invalid, "Prism text projection is closed")
        var output = render(doc, codec, adapter) catch failure:
            if failure.code == memory.exhausted:
                error(failure.code, failure.message)
            return false
        defer output.close()
        let next_name = (try (adapter else error(invalid, "missing codec adapter")).get()).name() if adapter != none else codecs.codec_name(codec)
        var remembered: View
        defer remembered.close()
        if self.parsed:
            remembered.canonical = try render(doc, self.current, self.custom)
            remembered.name = try text_copy(try self.codec_name())
            remembered.text = try self.buffer.copy()
        var restored: Buffer
        errdefer restored.close()
        var found = false
        for view in self.views.span():
            if view.name.view() == next_name and view.canonical.view() == output.view():
                restored = try view.text.copy()
                found = true
                break
        if not found:
            restored = try output.copy()
        if self.parsed:
            var replaced = false
            for i in 0..<self.views.count:
                if self.views.items[i].name.view() == remembered.name.view():
                    self.views.items[i].close()
                    self.views.items[i] = remembered
                    replaced = true
                    break
            if not replaced:
                try self.views.push(remembered)
            remembered = View()
        let retained = (adapter else error(invalid, "missing codec adapter")).clone() if adapter != none else none
        if let previous = self.custom:
            previous.release()
        self.custom = retained
        self.current = codec
        self.buffer.close()
        self.buffer = restored
        self.clear_error()
        return true

    pub func set_codec(codec: codecs.Codec) -> bool!:
        if codec == codecs.Codec.auto:
            return false
        try self.enter()
        defer self.leave()
        return try self.switch_view(codecs.Codec.prisma if codec == codecs.Codec.prism else codec, none)

    pub func set_adapter(adapter: interop.Reference[CodecAdapter]) -> bool!:
        try self.enter()
        defer self.leave()
        return try self.switch_view(codecs.Codec.auto, adapter)

    pub func set_text(text: str) -> bool!:
        try self.enter()
        defer self.leave()
        var next_text = try text_copy(text)
        defer next_text.close()
        var next: interop.Reference[Document]? = none
        defer release_document(next)
        var diagnosis: Buffer
        defer diagnosis.close()
        var line: usize = 0
        var column: usize = 0
        if let custom = self.custom:
            let bytes = try own_blob(try next_text.copy())
            defer bytes.release()
            next = (try custom.get()).decode(bytes) catch failure:
                if failure.code == memory.exhausted:
                    error(failure.code, failure.message)
                diagnosis = try text_copy(failure.message)
                line = 1
                column = 1
                recover none
            if let decoded = next:
                let rebased = try (try custom.get()).rebase_document(self.source else error(invalid, "missing projection document"), decoded)
                decoded.release()
                next = rebased
        else:
            let result = try decode_diagnosed(next_text.bytes(), self.current)
            defer result.release()
            if (try result.get()).ok():
                next = try (try result.get()).document()
            else:
                diagnosis = try text_copy((try result.get()).error_message())
                line = (try result.get()).line()
                column = (try result.get()).column()
        self.buffer.close()
        self.buffer = next_text
        next_text = Buffer()
        self.message.close()
        self.message = diagnosis
        diagnosis = Buffer()
        self.error_line = line
        self.error_column = column
        self.parsed = next != none
        if let doc = next:
            if let previous = self.source:
                previous.release()
            self.source = doc
            next = none
        return self.parsed

    pub func set_source(bytes: str, codec: codecs.Codec) -> bool!:
        if codec == codecs.Codec.auto or codec == codecs.Codec.prism:
            return false
        try self.enter()
        defer self.leave()
        let doc = codecs.decode(bytes.bytes, codec) catch failure:
            if failure.code == memory.exhausted:
                error(failure.code, failure.message)
            return false
        errdefer doc.release()
        var output = try text_copy(bytes)
        self.replace(doc, output)
        if let previous = self.custom:
            previous.release()
        self.custom = none
        self.current = codec
        clear_views(&self.views)
        return true

    pub func amend(document: interop.Reference[Document]) -> !:
        try self.enter()
        defer self.leave()
        let next = try (try document.get()).copy()
        errdefer next.release()
        var before = try render(self.source else error(invalid, "missing projection document"), self.current, self.custom)
        defer before.close()
        var after = try render(next, self.current, self.custom)
        defer after.close()
        if before.view() != after.view():
            error(invalid, "Prism projection amendment changes the rendered text")
        if let previous = self.source:
            previous.release()
        self.source = next

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        if let doc = self.source:
            doc.trace(visit, context)
        if let adapter = self.custom:
            adapter.trace(visit, context)

    pub func close():
        if self.busy:
            self.close_pending = true
            return
        if let doc = self.source:
            doc.release()
        if let adapter = self.custom:
            adapter.release()
        self.source = none
        self.custom = none
        self.buffer.close()
        self.message.close()
        clear_views(&self.views)

func release_document(doc: interop.Reference[Document]?):
    if let reference = doc:
        reference.release()

pub let text_projection_type = interop.Type[TextProjection]("Prism text projection", TextProjection.close, TextProjection.trace, closeable = true)