Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced

Source of release 0.4.1

0.4.1 / src / language / folding.luc

## Language-agnostic folding by indentation: a line whose following lines are more indented is a
## fold header, and its region runs to the last line indented past it. This works for every
## language the editor highlights — no lexer or grammar-specific structure needed — so folding and
## highlighting share one path. Offsets count Unicode scalars, exactly as TextEditor does.
from luce_ui.ui import TextEditor, FoldRange

pub class Folder:
    let editor: TextEditor
    var version: int

    pub func init(self, editor: TextEditor) -> unit:
        self.editor = editor
        self.version = -1

    pub func update(self) -> unit!:
        let revision = self.editor.version()
        if revision == self.version:
            return
        let length = self.editor.length()
        let text = self.editor.text_range(0, length)
        if self.editor.set_folds(compute_folds(text, length), revision):
            self.version = revision

## Fold ranges from the indentation structure of `text` (whose scalar length is `length`).
func compute_folds(text: str, length: int) -> list[FoldRange]:
    var starts: list[int] = []
    var indents: list[int] = []
    var filled: list[bool] = []
    var offset = 0
    var line_start = 0
    var indent = 0
    var leading = true
    var nonempty = false
    for character in text:
        if character == "\n":
            starts.append(line_start)
            indents.append(indent)
            filled.append(nonempty)
            offset += 1
            line_start = offset
            indent = 0
            leading = true
            nonempty = false
        else:
            if leading:
                if character == " ":
                    indent += 1
                elif character == "\t":
                    indent += 4 - indent % 4
                else:
                    leading = false
            if character != " " and character != "\t" and character != "\r":
                nonempty = true
            offset += 1
    starts.append(line_start)
    indents.append(indent)
    filled.append(nonempty)

    var folds: list[FoldRange] = []
    let count = starts.length
    var index = 0
    while index < count:
        if filled[index]:
            var scan = index + 1
            var last = index
            var deeper = false
            while scan < count:
                if not filled[scan]:
                    scan += 1
                    continue
                if indents[scan] > indents[index]:
                    deeper = true
                    last = scan
                    scan += 1
                else:
                    break
            if deeper:
                var stop = length
                var after = last + 1
                while after < count:
                    if filled[after]:
                        stop = starts[after]
                        break
                    after += 1
                folds.append(FoldRange(starts[index], stop))
        index += 1
    return folds