Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-message

Source of release 0.5.0

0.5.0 / src / mail_index.lucb

## What the window reads from the store: a folder list and a folder's message index,
## each read whole from a prism snapshot (mail_db) into an object Luce holds, with one
## accessor per column. Reading them in Base keeps a 50,000-message folder quick to open.
from luce_std import files
import interop
import memory
from luce_prism import prism
from luce_mime import mime
from luce_std.collections import Buffer, List
from mail_store import Row, Folder
from mail_threads import Threads, thread
import mail_db

## A folder's messages, as the store has them.
pub struct MessageIndex:
    var rows: mail_db.Rows
    ## Positions in UID order, for `position`.
    var by_uid: List[u32]
    ## Positions newest first: by date, then by UID.
    var order: List[u32]
    ## The messages grouped into conversations.
    var threads: Threads

    ## How many messages there are.
    pub func count() -> i64:
        return (i64)self.rows.rows.length()

    func row(at: i64) -> Row:
        if at < 0 or at >= (i64)self.rows.rows.length():
            trap("no message at that position in the index")
        return self.rows.rows.at((usize)at)

    pub func uid(at: i64) -> i64:
        return (i64)self.row(at).uid

    ## imap.Flags bits: 1 seen, 2 answered, 4 flagged, 8 deleted, 16 draft, 64 forwarded, 128 junk.
    pub func flags(at: i64) -> i64:
        return (i64)self.row(at).flags

    ## Seconds since 1970 UTC.
    pub func date(at: i64) -> i64:
        return self.row(at).date

    pub func size(at: i64) -> i64:
        return (i64)self.row(at).size

    pub func attachment(at: i64) -> bool:
        return self.row(at).attachment

    pub func sender(at: i64) -> str:
        return self.row(at).sender

    pub func subject(at: i64) -> str:
        return self.row(at).subject

    pub func message_id(at: i64) -> str:
        return self.row(at).message_id

    pub func in_reply_to(at: i64) -> str:
        return self.row(at).in_reply_to

    pub func preview(at: i64) -> str:
        return self.row(at).preview

    ## The position of the message with UID `uid`, or -1.
    pub func position(uid: i64) -> i64:
        var low: usize = 0
        var high = self.by_uid.length()
        while low < high:
            let middle = (low + high) // 2
            let at = self.by_uid.at(middle)
            let found = (i64)self.rows.rows.at((usize)at).uid
            if found == uid:
                return (i64)at
            if found < uid:
                low = middle + 1
            else:
                high = middle
        return -1

    ## The position of the `nth` newest message.
    pub func newest(nth: i64) -> i64:
        if nth < 0 or nth >= (i64)self.order.length():
            trap("no message at that place in the order")
        return (i64)self.order.at((usize)nth)

    ## Fill the UID and newest-first orders.
    func sort() -> !:
        let count = self.rows.rows.length()
        for at in 0..<count:
            try self.by_uid.append((u32)at)
            try self.order.append((u32)at)
        try self.merge_sort(&self.by_uid, true)
        try self.merge_sort(&self.order, false)

    ## Sort `positions` by UID (`by_uid`), else newest first; a stable merge sort, fast
    ## on the mostly sorted orders mailboxes have.
    func merge_sort(positions: List[u32]*, by_uid: bool) -> !:
        let count = positions.length()
        if count < 2:
            return
        let scratch = try new u32[count] --- in memory.heap
        defer free(scratch) in memory.heap
        var width: usize = 1
        while width < count:
            var start: usize = 0
            while start < count:
                let middle = start + width if start + width < count else count
                let end = start + 2 * width if start + 2 * width < count else count
                var left = start
                var right = middle
                var out = start
                while out < end:
                    var take_left = right >= end
                    if not take_left and left < middle:
                        let a = positions.at(left)
                        let b = positions.at(right)
                        take_left = not (self.uid_before(b, a) if by_uid else self.newer(b, a))
                    if take_left:
                        scratch[out] = positions.at(left)
                        left += 1
                    else:
                        scratch[out] = positions.at(right)
                        right += 1
                    out += 1
                start = end
            for at in 0..<count:
                positions.set(at, scratch[at])
            width *= 2

    func uid_before(a: u32, b: u32) -> bool:
        return self.rows.rows.at((usize)a).uid < self.rows.rows.at((usize)b).uid

    ## Whether the row at `a` is newer than the row at `b`.
    func newer(a: u32, b: u32) -> bool:
        let first = self.rows.rows.at((usize)a)
        let second = self.rows.rows.at((usize)b)
        if first.date != second.date:
            return first.date > second.date
        return first.uid > second.uid

    # mark: conversations ======================================================================

    ## How many conversations there are.
    pub func thread_count() -> i64:
        return (i64)self.threads.count()

    func checked_thread(nth: i64) -> usize:
        if nth < 0 or nth >= (i64)self.threads.count():
            trap("no conversation at that place")
        return (usize)nth

    ## How many messages conversation `nth` (newest first) holds.
    pub func thread_size(nth: i64) -> i64:
        return (i64)self.threads.size(self.checked_thread(nth))

    ## The position of the `member`-th newest message of conversation `nth`.
    pub func thread_member(nth: i64, member: i64) -> i64:
        let group = self.checked_thread(nth)
        if member < 0 or member >= (i64)self.threads.size(group):
            trap("no message at that place in the conversation")
        return (i64)self.threads.member(group, (usize)member)

    ## Whether any message of conversation `nth` has all of flag bits `bit`
    ## (`seen` asks for the inverse: whether any is unread).
    pub func thread_any(nth: i64, bit: i64, wanted: bool) -> bool:
        let group = self.checked_thread(nth)
        for member in 0..<self.threads.size(group):
            let flags = (i64)self.rows.rows.at((usize)self.threads.member(group, member)).flags
            if ((flags & bit) == bit) == wanted:
                return true
        return false

    ## Whether any message of conversation `nth` has attachments.
    pub func thread_attachment(nth: i64) -> bool:
        let group = self.checked_thread(nth)
        for member in 0..<self.threads.size(group):
            if self.rows.rows.at((usize)self.threads.member(group, member)).attachment:
                return true
        return false

    pub func close():
        self.rows.close()
        self.by_uid.destroy()
        self.order.destroy()
        self.threads.close()

pub let message_index_type: interop.Type[MessageIndex] = interop.Type[MessageIndex]("Message index", MessageIndex.close, closeable = true)

## The messages of folder identity `identity` in `store`; empty when it has none yet.
pub func read_index(store: interop.Reference[prism.Store], identity: str) -> interop.Reference[MessageIndex]!:
    let native = try new MessageIndex(rows = try mail_db.read_rows(try store.get(), identity)) in memory.heap
    errdefer free(native) in memory.heap
    try native.sort()
    native.threads = try thread(&native.rows.rows)
    return try interop.Reference[MessageIndex].adopt(native, message_index_type)

## Message `uid` of folder identity `identity`, parsed; none when its body is not in
## the store yet.
pub func open_message(store: interop.Reference[prism.Store], identity: str, uid: i64) -> interop.Reference[mime.Message]?!:
    if uid < 0 or uid > 0xFFFFFFFF:
        return none
    var raw: Buffer
    defer raw.destroy()
    if not try mail_db.read_raw(try store.get(), identity, (u32)uid, &raw):
        return none
    return try mime.parse(raw.view())

## The folders of one account, as the engine listed them.
pub struct FolderList:
    var listed: mail_db.Folders

    pub func count() -> i64:
        return (i64)self.listed.folders.length()

    func folder(at: i64) -> Folder:
        if at < 0 or at >= (i64)self.listed.folders.length():
            trap("no folder at that position")
        return self.listed.folders.at((usize)at)

    ## The server's name for folder `at`, used in commands.
    pub func path(at: i64) -> str:
        return self.folder(at).path

    ## The name to show.
    pub func name(at: i64) -> str:
        return self.folder(at).name

    ## The hierarchy delimiter as a character code, zero for none.
    pub func delimiter(at: i64) -> i64:
        return (i64)self.folder(at).delimiter

    ## imap.MailboxFlags bits: 256 all, 512 archive, 1024 drafts, 2048 flagged, 4096 junk,
    ## 8192 sent, 16384 trash.
    pub func flags(at: i64) -> i64:
        return (i64)self.folder(at).flags

    ## How many levels down folder `at` is: the delimiters in its path.
    pub func depth(at: i64) -> i64:
        let folder = self.folder(at)
        if folder.delimiter == 0:
            return 0
        var count: i64 = 0
        for byte in folder.path.bytes:
            if byte == folder.delimiter:
                count += 1
        return count

    ## The last part of folder `at`'s name: `2026` for `Archive/2026`.
    pub func leaf(at: i64) -> str:
        let folder = self.folder(at)
        if folder.delimiter == 0:
            return folder.name
        let data = folder.name.bytes
        var start: usize = 0
        for index in 0..<data.length:
            if data[index] == folder.delimiter:
                start = index + 1
        return (str)data[start..]

    ## The folder's directory name in the store.
    pub func key(at: i64) -> str:
        return self.folder(at).key

    pub func total(at: i64) -> i64:
        return (i64)self.folder(at).total

    pub func unseen(at: i64) -> i64:
        return (i64)self.folder(at).unseen

    pub func close():
        self.listed.close()

pub let folder_list_type: interop.Type[FolderList] = interop.Type[FolderList]("Folder list", FolderList.close, closeable = true)

## The folders of account `account` in `store`; empty when it has none yet.
pub func read_folders(store: interop.Reference[prism.Store], account: str) -> interop.Reference[FolderList]!:
    let native = try new FolderList(listed = try mail_db.read_folders(try store.get(), account)) in memory.heap
    return try interop.Reference[FolderList].adopt(native, folder_list_type)

## Whether a file or directory exists at `path`.
pub func exists(path: str) -> bool:
    var name: Buffer
    defer name.destroy()
    name.put_text(path) catch failure:
        return false
    let file = name.terminated() catch failure:
        return false
    return files.exists(file)

## Whether flag word `flags` has every bit of `bit` set: Luce has no bit operations.
pub func has(flags: i64, bit: i64) -> bool:
    return (flags & bit) == bit