dymokomi/luced-message
Source of release 0.5.0
## Where messages come from. The window knows only Source: folders, the messages in a
## folder, a message's file, and actions on messages. EmailSource is the first kind:
## an IMAP/SMTP account served by a mail engine on its own thread (mail_service),
## whose writes to the mail database (mail_db) the window reads. Other kinds (JMAP, Matrix, RSS) implement the same
## interface over their own engines.
from accounts import Account, escape
import mail_service
from mail_service import MailService
import mail_index
from mail_index import MessageIndex
from luce_prism import prism
from luce_mime import mime
import mail_db
## Message flag bits, as the store keeps them (imap.Flags).
pub let seen_flag: int = 1
pub let answered_flag: int = 2
pub let flagged_flag: int = 4
pub let deleted_flag: int = 8
pub let draft_flag: int = 16
pub let forwarded_flag: int = 64
pub let junk_flag: int = 128
## A folder as the window shows it.
pub struct FolderInfo:
## The source's own name for it, used in actions.
pub let path: str
pub let name: str
## inbox, sent, drafts, trash, junk, archive, all, flagged, or "".
pub let role: str
pub let depth: int
pub let total: int
pub let unseen: int
## Something a source has to tell the window.
pub struct SourceEvent:
## online, offline, status, folders, folder, body, sent, unsent, error.
pub let kind: str
pub let folder: str = ""
pub let uid: int = 0
pub let text: str = ""
pub interface Source:
func id(self) -> str
func title(self) -> str
func address(self) -> str
func folders(self) -> list[FolderInfo]!
func messages(self, folder: str) -> MessageIndex!
## Message `uid`, or none when its body is not fetched yet (see `fetch`).
func message(self, folder: str, uid: int) -> mime.Message?!
func fetch(self, folder: str, uid: int) -> unit!
func set_flags(self, folder: str, uids: list[int], add: bool, bits: int) -> unit!
## Move messages to the folder with `role` (trash, junk, archive); false when the
## source has no such folder.
func move_to(self, folder: str, uids: list[int], role: str) -> bool!
## Send `message` (RFC 5322 text) from `sender` to `recipients`.
func send(self, message: str, sender: str, recipients: list[str]) -> unit!
## Keep `message` (RFC 5322 text) as a draft (the account's Drafts folder).
func save_draft(self, message: str) -> unit!
## Ask which messages of `folder` hold `query` anywhere; the answer comes as a
## `found` event whose text is the matching UIDs, comma-separated.
func search(self, folder: str, query: str) -> unit!
func refresh(self) -> unit!
func poll(self) -> list[SourceEvent]!
func close(self)
## The role of a folder from its special-use bits (RFC 6154), else from the names
## servers without them use.
pub func role_of(name: str, flags: int) -> str:
if name.upper() == "INBOX":
return "inbox"
let bits = [(8192, "sent"), (1024, "drafts"), (16384, "trash"), (4096, "junk"), (512, "archive"), (256, "all"), (2048, "flagged")]
for (bit, role) in bits:
if mail_index.has(flags, bit):
return role
let parts = name.replace(".", "/").split("/")
let leaf = parts[parts.length - 1].lower()
let names = [("sent", "sent"), ("sent items", "sent"), ("sent messages", "sent"), ("sent mail", "sent"),
("drafts", "drafts"), ("trash", "trash"), ("deleted items", "trash"), ("deleted messages", "trash"),
("bin", "trash"), ("junk", "junk"), ("spam", "junk"), ("junk e-mail", "junk"), ("archive", "archive"),
("archives", "archive")]
for (known, role) in names:
if leaf == known:
return role
return ""
## An email account: IMAP to read, SMTP to send.
pub class EmailSource: Source:
let account: Account
## The mail database every account shares.
let mail: prism.Store
let service: MailService
## Folder paths by role, from the last folder list.
var roles: map[str, str] = {}
## Folder store keys by path.
var keys: map[str, str] = {}
pub func init(self, account: Account, mail: prism.Store) -> unit!:
self.account = account
self.mail = mail
self.service = mail_service.start_service(account.engine_line(), mail)
pub func id(self) -> str:
return self.account.id
pub func title(self) -> str:
return self.account.title()
pub func address(self) -> str:
return self.account.address
pub func folders(self) -> list[FolderInfo]!:
let listing = mail_index.read_folders(self.mail, self.account.id)
var result: list[FolderInfo] = []
self.roles = {}
self.keys = {}
for at in 0..<listing.count():
let path = listing.path(at)
let role = role_of(path, listing.flags(at))
let depth = listing.depth(at)
let name = listing.leaf(at)
if role != "" and not (role in self.roles):
self.roles[role] = path
self.keys[path] = listing.key(at)
result.append(FolderInfo(path = path, name = "Inbox" if role == "inbox" else name, role = role, depth = depth,
total = listing.total(at), unseen = listing.unseen(at)))
return result
pub func messages(self, folder: str) -> MessageIndex!:
let key = self.keys[folder] else ""
if key == "":
return mail_index.read_index(self.mail, "")
return mail_index.read_index(self.mail, f"{self.account.id}.{key}")
pub func message(self, folder: str, uid: int) -> mime.Message?!:
let key = self.keys[folder] else ""
if key == "":
return none
return mail_index.open_message(self.mail, f"{self.account.id}.{key}", uid)
pub func fetch(self, folder: str, uid: int) -> unit!:
self.service.submit(f"body\t{escape(folder)}\t{uid}")
pub func set_flags(self, folder: str, uids: list[int], add: bool, bits: int) -> unit!:
self.service.submit(f"flags\t{escape(folder)}\t{uid_set(uids)}\t{1 if add else 0}\t{bits}")
pub func move_to(self, folder: str, uids: list[int], role: str) -> bool!:
let target = self.roles[role] else return false
if target == folder:
return false
self.service.submit(f"move\t{escape(folder)}\t{uid_set(uids)}\t{escape(target)}")
return true
pub func send(self, message: str, sender: str, recipients: list[str]) -> unit!:
let queued = mail_db.queue(self.mail, self.account.id, message)
let joined = recipients.join(",")
self.service.submit(f"send\t{escape(queued)}\t{escape(sender)}\t{escape(joined)}")
pub func save_draft(self, message: str) -> unit!:
let queued = mail_db.queue(self.mail, self.account.id, message)
self.service.submit(f"draft\t{escape(queued)}")
pub func search(self, folder: str, query: str) -> unit!:
self.service.submit(f"search\t{escape(folder)}\t{escape(query)}")
pub func refresh(self) -> unit!:
self.service.submit("sync")
pub func poll(self) -> list[SourceEvent]!:
var events: list[SourceEvent] = []
let text = self.service.poll()
if text == "":
return events
for line in text.lines():
let fields = line.split("\t")
let kind = fields[0]
if kind == "folder":
events.append(SourceEvent(kind = kind, folder = unescape(fields[1])))
elif kind == "found":
events.append(SourceEvent(kind = kind, folder = unescape(fields[1]), text = fields[2] if fields.length > 2 else ""))
elif kind == "body":
events.append(SourceEvent(kind = kind, folder = unescape(fields[1]), uid = int(fields[2])))
elif fields.length > 1:
events.append(SourceEvent(kind = kind, text = unescape(fields[1])))
else:
events.append(SourceEvent(kind = kind))
return events
pub func close(self):
self.service.close()
## UIDs as a comma-separated set.
func uid_set(uids: list[int]) -> str:
var parts: list[str] = []
for uid in uids:
parts.append(f"{uid}")
return parts.join(",")
## An engine field with its escapes undone.
func unescape(text: str) -> str:
if not ("\\" in text):
return text
var out = ""
var escaped = false
for character in text:
if escaped:
out = out + ("\t" if character == "t" else ("\n" if character == "n" else ("\r" if character == "r" else character)))
escaped = false
elif character == "\\":
escaped = true
else:
out = out + character
return out