C12.9: three-pane mailbox view, filters, virtualized list; ids never reused
This commit is contained in:
29 files changed
+1274
-75
No files matched your search
@@ -0,0 +1,204 @@
|
||||
//! What the window has open, and its list.
|
||||
|
||||
use std::{collections::HashMap, rc::Rc};
|
||||
|
||||
use ely_gpui_component::mail::Mail as Row;
|
||||
use ely_mail_engine::{AccountId, Filter, MailboxId, Role, Scope, Summary};
|
||||
use gpui::{Context, SharedString};
|
||||
|
||||
use crate::mail::{Mail, text};
|
||||
|
||||
pub type Unread = HashMap<MailboxId, u32>;
|
||||
|
||||
/// What the middle of the window shows.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Open {
|
||||
Inboxes,
|
||||
Mailbox(AccountId, MailboxId),
|
||||
/// The account's settings and sync.
|
||||
Account(AccountId),
|
||||
}
|
||||
|
||||
impl Open {
|
||||
pub fn key(self) -> SharedString {
|
||||
match self {
|
||||
Open::Inboxes => "inboxes".into(),
|
||||
Open::Mailbox(_, mailbox) => format!("box-{}", mailbox.0).into(),
|
||||
Open::Account(id) => format!("account-{}", id.0).into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn account(self) -> Option<AccountId> {
|
||||
match self {
|
||||
Open::Inboxes => None,
|
||||
Open::Mailbox(id, _) | Open::Account(id) => Some(id),
|
||||
}
|
||||
}
|
||||
|
||||
fn scope(self) -> Option<Scope> {
|
||||
match self {
|
||||
Open::Inboxes => Some(Scope::Inboxes),
|
||||
Open::Mailbox(_, mailbox) => Some(Scope::Mailbox(mailbox)),
|
||||
Open::Account(_) => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Rows read, and where each key sits.
|
||||
pub struct Indexed {
|
||||
rows: Vec<Row>,
|
||||
at: HashMap<SharedString, usize>,
|
||||
}
|
||||
|
||||
/// Off the UI thread: a long list takes a while.
|
||||
pub fn index(rows: Vec<Row>) -> Indexed {
|
||||
let at = rows
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(ix, row)| (row.key.clone(), ix))
|
||||
.collect();
|
||||
Indexed { rows, at }
|
||||
}
|
||||
|
||||
/// The open list and the messages picked in it.
|
||||
#[derive(Default)]
|
||||
pub struct Listing {
|
||||
/// Numbers reads; an older one is dropped.
|
||||
pub read: u64,
|
||||
/// None until read, or when nothing lists mail.
|
||||
pub mails: Option<Result<Rc<Vec<Row>>, String>>,
|
||||
at: HashMap<SharedString, usize>,
|
||||
pub selected: Vec<SharedString>,
|
||||
/// The one message picked, for the reading pane.
|
||||
pub chosen: Option<Row>,
|
||||
}
|
||||
|
||||
impl Listing {
|
||||
pub fn show(&mut self, mails: Option<Result<Indexed, String>>) {
|
||||
self.at = HashMap::new();
|
||||
self.mails = mails.map(|read| {
|
||||
read.map(|indexed| {
|
||||
self.at = indexed.at;
|
||||
Rc::new(indexed.rows)
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
/// Keeps the picks still listed.
|
||||
fn pick(&mut self, keys: Vec<SharedString>) {
|
||||
let Some(Ok(mails)) = &self.mails else {
|
||||
self.selected.clear();
|
||||
self.chosen = None;
|
||||
return;
|
||||
};
|
||||
self.selected = keys
|
||||
.into_iter()
|
||||
.filter(|key| self.at.contains_key(key))
|
||||
.collect();
|
||||
self.chosen = match &self.selected[..] {
|
||||
[key] => Some(mails[self.at[key]].clone()),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl Mail {
|
||||
pub fn open_box(&mut self, open: Open, cx: &mut Context<Self>) {
|
||||
log::info!("mail: open {}", open.key());
|
||||
if open != self.open {
|
||||
self.open = open;
|
||||
self.listing.show(None);
|
||||
self.listing.pick(Vec::new());
|
||||
}
|
||||
self.read_mail(cx);
|
||||
self.notify(cx);
|
||||
}
|
||||
|
||||
pub fn set_filter(&mut self, filter: Filter, cx: &mut Context<Self>) {
|
||||
log::info!("mail: filter {filter:?}");
|
||||
self.filter = filter;
|
||||
self.read_mail(cx);
|
||||
cx.notify();
|
||||
}
|
||||
|
||||
pub fn select(&mut self, keys: &[SharedString], cx: &mut Context<Self>) {
|
||||
self.listing.pick(keys.to_vec());
|
||||
cx.notify();
|
||||
}
|
||||
|
||||
/// Unread counts, and the open list when it lists mail.
|
||||
pub fn read_mail(&mut self, cx: &mut Context<Self>) {
|
||||
self.listing.read += 1;
|
||||
let (read, scope, filter) = (self.listing.read, self.open.scope(), self.filter);
|
||||
let none = (
|
||||
text(cx, "mail.no_sender", &[]),
|
||||
text(cx, "mail.no_subject", &[]),
|
||||
);
|
||||
self.with_store(
|
||||
cx,
|
||||
move |store| {
|
||||
let rows = match scope {
|
||||
Some(scope) => {
|
||||
let list = store.list(scope, filter)?;
|
||||
Some(index(
|
||||
list.into_iter().map(|each| row(each, &none)).collect(),
|
||||
))
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
Ok((rows, store.unread()?))
|
||||
},
|
||||
move |mail, read_now, _| {
|
||||
if mail.listing.read != read {
|
||||
return log::info!("mail: list read {read} ended after a newer one");
|
||||
}
|
||||
match read_now {
|
||||
Ok((rows, unread)) => {
|
||||
mail.unread = unread;
|
||||
mail.listing.show(rows.map(Ok));
|
||||
}
|
||||
Err(error) => {
|
||||
log::warn!("mail: list read {read} failed: {error}");
|
||||
mail.listing.show(scope.map(|_| Err(error)));
|
||||
}
|
||||
}
|
||||
let keys = std::mem::take(&mut mail.listing.selected);
|
||||
mail.listing.pick(keys);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/// Unread mail in every account's inbox.
|
||||
pub fn inboxes_unread(&self) -> u32 {
|
||||
self.syncs
|
||||
.values()
|
||||
.flat_map(|syncing| &syncing.folders)
|
||||
.filter(|folder| folder.role == Some(Role::Inbox))
|
||||
.filter_map(|folder| self.unread.get(&folder.id))
|
||||
.sum()
|
||||
}
|
||||
}
|
||||
|
||||
/// `none` names a missing sender, then subject.
|
||||
fn row(summary: Summary, none: &(SharedString, SharedString)) -> Row {
|
||||
let key = summary.id.0.to_string();
|
||||
let from = summary.from.first().map(|from| match &from.name {
|
||||
Some(name) if !name.trim().is_empty() => name.clone(),
|
||||
_ => from.email.clone(),
|
||||
});
|
||||
let from: SharedString = from.map_or_else(|| none.0.clone(), Into::into);
|
||||
let subject: SharedString = summary.subject.map_or_else(|| none.1.clone(), Into::into);
|
||||
let row = match summary.date.map(jiff::Timestamp::from_second) {
|
||||
Some(Ok(at)) => Row::new(key, from, subject, at),
|
||||
Some(Err(error)) => {
|
||||
log::warn!("mail: message {} date unshown: {error}", summary.id.0);
|
||||
Row::undated(key, from, subject)
|
||||
}
|
||||
None => Row::undated(key, from, subject),
|
||||
};
|
||||
let row = row.unread(!summary.seen).starred(summary.flagged);
|
||||
match summary.attachments {
|
||||
Some(count) => row.attachments(count as usize),
|
||||
None => row,
|
||||
}
|
||||
}
|
||||
@@ -251,7 +251,7 @@ impl Mail {
|
||||
if let Some(Ok(accounts)) = &mut mail.accounts {
|
||||
accounts.push((id, account));
|
||||
}
|
||||
mail.picked = Some(id);
|
||||
mail.open_box(crate::boxes::Open::Account(id), cx);
|
||||
mail.sync(id, cx);
|
||||
if mail.awaiting(asked).is_some() {
|
||||
mail.adding = None;
|
||||
|
||||
+21
-13
@@ -7,13 +7,19 @@ use std::{
|
||||
};
|
||||
|
||||
use ely_gpui_component::primitives::Severity;
|
||||
use ely_mail_engine::{Account, AccountId, Store, TlsConnector, Vault};
|
||||
use ely_mail_engine::{Account, AccountId, Filter, Store, TlsConnector, Vault};
|
||||
use ely_platform::AppId;
|
||||
use ely_ui::Root;
|
||||
use gpui::{App, AppContext as _, Context, Entity, FocusHandle, SharedString, WeakEntity, Window};
|
||||
use tokio::runtime::Runtime;
|
||||
|
||||
use crate::{adding::Adding, removing::Removing, side::Side, syncing::Syncs};
|
||||
use crate::{
|
||||
adding::Adding,
|
||||
boxes::{Listing, Open, Unread},
|
||||
removing::Removing,
|
||||
side::Side,
|
||||
syncing::Syncs,
|
||||
};
|
||||
|
||||
/// What the engine runs on and keeps to.
|
||||
pub struct Parts {
|
||||
@@ -40,7 +46,11 @@ pub struct Mail {
|
||||
runtime: Arc<Runtime>,
|
||||
/// None until read.
|
||||
pub accounts: Option<Result<Vec<(AccountId, Account)>, String>>,
|
||||
pub picked: Option<AccountId>,
|
||||
/// Remove acts on its account.
|
||||
pub open: Open,
|
||||
pub filter: Filter,
|
||||
pub listing: Listing,
|
||||
pub unread: Unread,
|
||||
pub adding: Option<Adding>,
|
||||
pub removing: Option<Removing>,
|
||||
pub syncs: Syncs,
|
||||
@@ -102,7 +112,10 @@ impl Mail {
|
||||
tls: parts.tls,
|
||||
runtime: Arc::new(runtime),
|
||||
accounts: None,
|
||||
picked: None,
|
||||
open: Open::Inboxes,
|
||||
filter: Filter::default(),
|
||||
listing: Listing::default(),
|
||||
unread: Unread::new(),
|
||||
adding: None,
|
||||
removing: None,
|
||||
syncs: Syncs::new(),
|
||||
@@ -126,15 +139,15 @@ impl Mail {
|
||||
let first = mail.accounts.is_none();
|
||||
if let Ok(accounts) = &read {
|
||||
let still = |id| accounts.iter().any(|(each, _)| *each == id);
|
||||
mail.picked = mail
|
||||
.picked
|
||||
.filter(|id| still(*id))
|
||||
.or_else(|| accounts.first().map(|(id, _)| *id));
|
||||
if mail.open.account().is_some_and(|id| !still(id)) {
|
||||
mail.open = Open::Inboxes;
|
||||
}
|
||||
}
|
||||
mail.accounts = Some(read);
|
||||
if first {
|
||||
mail.sync_all(cx);
|
||||
}
|
||||
mail.read_mail(cx);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -146,11 +159,6 @@ impl Mail {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn pick(&mut self, id: AccountId, cx: &mut Context<Self>) {
|
||||
self.picked = Some(id);
|
||||
self.notify(cx);
|
||||
}
|
||||
|
||||
/// Redraws the window and its account list.
|
||||
pub fn notify(&self, cx: &mut Context<Self>) {
|
||||
self.side.update(cx, |_, cx| cx.notify());
|
||||
|
||||
@@ -3,11 +3,13 @@
|
||||
|
||||
mod add_view;
|
||||
mod adding;
|
||||
mod boxes;
|
||||
mod controls;
|
||||
mod flow;
|
||||
mod kinds;
|
||||
mod mail;
|
||||
mod menu;
|
||||
mod panes;
|
||||
mod removing;
|
||||
mod side;
|
||||
mod syncing;
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
//! The message list and the reading pane (C12.9).
|
||||
|
||||
use ely_gpui_component::{
|
||||
buttons::{ToggleGroup, ToggleItem},
|
||||
data_display::DescriptionList,
|
||||
feedback::{EmptyState, ErrorView},
|
||||
layout::SplitPane,
|
||||
mail::MailList,
|
||||
primitives::IconName,
|
||||
};
|
||||
use ely_mail_engine::Filter;
|
||||
use gpui::{
|
||||
AnyElement, Axis, Context, IntoElement, ParentElement as _, SharedString, Styled as _, div, px,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
mail::{Mail, text},
|
||||
view::local_time,
|
||||
};
|
||||
|
||||
type Filtered = fn(Filter) -> bool;
|
||||
|
||||
const FILTERS: [(&str, &str, IconName, Filtered); 3] = [
|
||||
("unread", "mail.filter.unread", IconName::Mail, |f| f.unread),
|
||||
("flagged", "mail.filter.flagged", IconName::Star, |f| {
|
||||
f.flagged
|
||||
}),
|
||||
(
|
||||
"attachments",
|
||||
"mail.filter.attachments",
|
||||
IconName::Paperclip,
|
||||
|f| f.attachments,
|
||||
),
|
||||
];
|
||||
|
||||
impl Mail {
|
||||
pub fn panes(&self, cx: &mut Context<Self>) -> AnyElement {
|
||||
SplitPane::new("mail-panes", Axis::Horizontal, px(240.))
|
||||
.pane(self.list_pane(cx))
|
||||
.pane(self.reader(cx))
|
||||
.into_any_element()
|
||||
}
|
||||
|
||||
fn list_pane(&self, cx: &mut Context<Self>) -> AnyElement {
|
||||
let on: Vec<&str> = FILTERS
|
||||
.iter()
|
||||
.filter(|(_, _, _, on)| on(self.filter))
|
||||
.map(|(key, _, _, _)| *key)
|
||||
.collect();
|
||||
let toggles = FILTERS.iter().fold(
|
||||
ToggleGroup::new("mail-filters").multiple().selected(on),
|
||||
|group, (key, label, icon, _)| {
|
||||
let words = text(cx, label, &[]);
|
||||
group.item(ToggleItem::new(*key).icon(*icon).label(words))
|
||||
},
|
||||
);
|
||||
let this = cx.weak_entity();
|
||||
let toggles = toggles.on_change(move |keys, _, cx| {
|
||||
let has = |key: &str| keys.iter().any(|each| each == key);
|
||||
let filter = Filter {
|
||||
unread: has("unread"),
|
||||
flagged: has("flagged"),
|
||||
attachments: has("attachments"),
|
||||
};
|
||||
this.update(cx, |mail, cx| mail.set_filter(filter, cx)).ok();
|
||||
});
|
||||
let list = match &self.listing.mails {
|
||||
None => div().into_any_element(),
|
||||
Some(Err(detail)) => ErrorView::new(
|
||||
"mail-list-error",
|
||||
IconName::TriangleAlert,
|
||||
text(cx, "mail.list.unread", &[]),
|
||||
)
|
||||
.detail(detail.clone())
|
||||
.into_any_element(),
|
||||
Some(Ok(mails)) => {
|
||||
let this = cx.weak_entity();
|
||||
MailList::new("mail-list", mails.clone())
|
||||
.selected(self.listing.selected.clone())
|
||||
.on_select(move |keys, _, cx| {
|
||||
this.update(cx, |mail, cx| mail.select(keys, cx)).ok();
|
||||
})
|
||||
.into_any_element()
|
||||
}
|
||||
};
|
||||
div()
|
||||
.size_full()
|
||||
.flex()
|
||||
.flex_col()
|
||||
.child(div().p_2().child(toggles))
|
||||
.child(div().flex_1().min_h_0().child(list))
|
||||
.into_any_element()
|
||||
}
|
||||
|
||||
fn reader(&self, cx: &mut Context<Self>) -> AnyElement {
|
||||
let Some(row) = &self.listing.chosen else {
|
||||
return EmptyState::new(
|
||||
"mail-reader-empty",
|
||||
IconName::Mail,
|
||||
text(cx, "mail.reader.none", &[]),
|
||||
)
|
||||
.into_any_element();
|
||||
};
|
||||
let label = |key: &str| text(cx, key, &[]);
|
||||
let date: SharedString = match row.at {
|
||||
Some(at) => local_time(at.as_second()).into(),
|
||||
None => label("mail.reader.no_date"),
|
||||
};
|
||||
let details = DescriptionList::new()
|
||||
.text(label("mail.reader.from"), row.from.clone())
|
||||
.text(label("mail.reader.date"), date);
|
||||
div()
|
||||
.p_6()
|
||||
.flex()
|
||||
.flex_col()
|
||||
.gap_4()
|
||||
.child(div().text_xl().child(row.subject.clone()))
|
||||
.child(details)
|
||||
.into_any_element()
|
||||
}
|
||||
}
|
||||
@@ -16,7 +16,10 @@ pub struct Removing {
|
||||
impl Mail {
|
||||
/// Measures what goes, then asks.
|
||||
pub fn ask_remove(&mut self, cx: &mut Context<Self>) {
|
||||
let Some(id) = self.picked else { return };
|
||||
let Some(id) = self.open.account() else {
|
||||
let words = text(cx, "mail.remove.none", &[]);
|
||||
return self.toast(words, Severity::Info, cx);
|
||||
};
|
||||
self.with_store(
|
||||
cx,
|
||||
move |store| store.cached(id),
|
||||
|
||||
+100
-25
@@ -1,14 +1,19 @@
|
||||
//! The account list down the left.
|
||||
//! Every inbox, then each account's folders, down the left.
|
||||
|
||||
use ely_gpui_component::lists::{ListItem, SelectableList};
|
||||
use ely_mail_engine::AccountId;
|
||||
use ely_gpui_component::{
|
||||
layout::ScrollArea,
|
||||
mail::{Mailbox, MailboxList},
|
||||
primitives::IconName,
|
||||
};
|
||||
use ely_mail_engine::{LocalFolder, Role};
|
||||
use gpui::{
|
||||
Context, IntoElement, ParentElement as _, Render, Styled as _, WeakEntity, Window, div,
|
||||
App, Context, IntoElement, ParentElement as _, Render, SharedString, Styled as _, WeakEntity,
|
||||
Window, div,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
boxes::Open,
|
||||
mail::{Mail, text},
|
||||
view::protocol,
|
||||
};
|
||||
|
||||
pub struct Side {
|
||||
@@ -24,28 +29,98 @@ impl Side {
|
||||
impl Render for Side {
|
||||
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
||||
let Some(mail) = self.mail.upgrade() else {
|
||||
return div();
|
||||
return div().into_any_element();
|
||||
};
|
||||
let mail = mail.read(cx);
|
||||
let list = mail.accounts().iter().fold(
|
||||
SelectableList::new("mail-accounts").label(text(cx, "mail.accounts", &[])),
|
||||
|list, (id, account)| {
|
||||
let item = ListItem::new(("mail-account", id.0 as u64), account.address.clone())
|
||||
.description(protocol(account, cx));
|
||||
list.row(id.0.to_string(), item)
|
||||
},
|
||||
);
|
||||
let pick = self.mail.clone();
|
||||
let list = list
|
||||
.selected(mail.picked.map(|id| id.0.to_string()))
|
||||
.on_change(move |keys, _, cx| {
|
||||
let Some(id) = keys.first().and_then(|key| key.parse().ok()) else {
|
||||
return log::error!("mail: the account list sent no account");
|
||||
};
|
||||
pick.update(cx, |mail, cx| mail.pick(AccountId(id), cx))
|
||||
.ok();
|
||||
let inboxes = Mailbox::new(
|
||||
Open::Inboxes.key(),
|
||||
text(cx, "mail.boxes.all", &[]),
|
||||
IconName::Inbox,
|
||||
)
|
||||
.unread(mail.inboxes_unread());
|
||||
let mut list =
|
||||
MailboxList::new("mail-boxes").section(text(cx, "mail.boxes.unified", &[]), [inboxes]);
|
||||
for (id, account) in mail.accounts() {
|
||||
let folders = mail.syncs.get(id).map_or(&[][..], |each| &each.folders);
|
||||
let mut sorted: Vec<&LocalFolder> = folders.iter().collect();
|
||||
sorted.sort_by(|a, b| rank(a.role).cmp(&rank(b.role)).then(a.name.cmp(&b.name)));
|
||||
let boxes = sorted.into_iter().map(|folder| {
|
||||
let open = Open::Mailbox(*id, folder.id);
|
||||
// Boxes with nothing unread are absent.
|
||||
let unread = mail.unread.get(&folder.id).copied().unwrap_or(0);
|
||||
Mailbox::new(open.key(), name(folder, cx), icon(folder.role)).unread(unread)
|
||||
});
|
||||
let settings = Mailbox::new(
|
||||
Open::Account(*id).key(),
|
||||
text(cx, "mail.boxes.settings", &[]),
|
||||
IconName::Settings,
|
||||
);
|
||||
list = list.section(account.address.clone(), boxes.chain([settings]));
|
||||
}
|
||||
let this = self.mail.clone();
|
||||
let list = list.open(mail.open.key()).on_open(move |key, _, cx| {
|
||||
this.update(cx, |mail, cx| match mail.opened(key) {
|
||||
Some(open) => mail.open_box(open, cx),
|
||||
None => log::error!("mail: the mailbox list sent an unknown box"),
|
||||
})
|
||||
.size_full();
|
||||
div().size_full().p_2().child(list)
|
||||
.ok();
|
||||
});
|
||||
ScrollArea::new("mail-side-scroll")
|
||||
.vertical()
|
||||
.size_full()
|
||||
.child(div().p_2().child(list))
|
||||
.into_any_element()
|
||||
}
|
||||
}
|
||||
|
||||
impl Mail {
|
||||
/// The box a side key names, if still here.
|
||||
fn opened(&self, key: &SharedString) -> Option<Open> {
|
||||
if *key == Open::Inboxes.key() {
|
||||
return Some(Open::Inboxes);
|
||||
}
|
||||
self.accounts().iter().find_map(|(id, _)| {
|
||||
let folders = self.syncs.get(id).map_or(&[][..], |each| &each.folders);
|
||||
let boxes = folders.iter().map(|folder| Open::Mailbox(*id, folder.id));
|
||||
boxes
|
||||
.chain([Open::Account(*id)])
|
||||
.find(|open| open.key() == *key)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Inbox in the reader's words; others as named.
|
||||
fn name(folder: &LocalFolder, cx: &App) -> SharedString {
|
||||
match folder.role {
|
||||
Some(Role::Inbox) => text(cx, "mail.boxes.inbox", &[]),
|
||||
_ => folder.name.clone().into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn rank(role: Option<Role>) -> u8 {
|
||||
match role {
|
||||
Some(Role::Inbox) => 0,
|
||||
Some(Role::Flagged) => 1,
|
||||
Some(Role::Drafts) => 2,
|
||||
Some(Role::Sent) => 3,
|
||||
Some(Role::Archive) => 4,
|
||||
Some(Role::All) => 5,
|
||||
Some(Role::Junk) => 6,
|
||||
Some(Role::Trash) => 7,
|
||||
None => 8,
|
||||
}
|
||||
}
|
||||
|
||||
fn icon(role: Option<Role>) -> IconName {
|
||||
match role {
|
||||
Some(Role::Inbox) => IconName::Inbox,
|
||||
Some(Role::Flagged) => IconName::Star,
|
||||
Some(Role::Drafts) => IconName::File,
|
||||
Some(Role::Sent) => IconName::Send,
|
||||
Some(Role::Archive) => IconName::Archive,
|
||||
Some(Role::All) => IconName::Mail,
|
||||
Some(Role::Junk) => IconName::TriangleAlert,
|
||||
Some(Role::Trash) => IconName::Trash2,
|
||||
None => IconName::Folder,
|
||||
}
|
||||
}
|
||||
@@ -177,6 +177,7 @@ impl Mail {
|
||||
(Ok((synced, folders)), Some(syncing)) => {
|
||||
syncing.synced = Some(synced);
|
||||
syncing.folders = folders;
|
||||
mail.read_mail(cx);
|
||||
}
|
||||
(Err(error), Some(_)) => mail.failed("mail.sync.unread", &error, cx),
|
||||
(_, None) => {}
|
||||
|
||||
@@ -23,6 +23,7 @@ use crate::{
|
||||
|
||||
mod controls;
|
||||
mod flows;
|
||||
mod panes;
|
||||
mod syncs;
|
||||
|
||||
/// A credential store that keeps or refuses.
|
||||
|
||||
@@ -10,7 +10,7 @@ use gpui::{
|
||||
};
|
||||
|
||||
use super::{Keys, account, settle, window};
|
||||
use crate::{mail::Mail, syncing::EVERY, view::imap_range};
|
||||
use crate::{boxes::Open, mail::Mail, syncing::EVERY, view::imap_range};
|
||||
|
||||
/// An account on a server that never answers.
|
||||
fn silent(dir: &std::path::Path, port: u16) -> AccountId {
|
||||
@@ -252,6 +252,7 @@ fn the_account_page_scrolls_to_its_last_folder() {
|
||||
.unwrap();
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(Open::Account(ann), cx)));
|
||||
cx.simulate_resize(size(px(1100.), px(800.)));
|
||||
settle(cx, |app| {
|
||||
mail.read(app)
|
||||
@@ -315,3 +316,23 @@ fn the_range_names_the_folders_kept_whole() {
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_needs_an_open_account() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
Store::open(dir.path())
|
||||
.unwrap()
|
||||
.add_account(&account("ann@example.com"))
|
||||
.unwrap();
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
settle(cx, |app| mail.read(app).accounts().len() == 1);
|
||||
cx.update(|_, app| assert_eq!(mail.read(app).open, Open::Inboxes));
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.ask_remove(cx)));
|
||||
cx.run_until_parked();
|
||||
cx.update(|_, app| {
|
||||
let mail = mail.read(app);
|
||||
assert!(mail.removing.is_none());
|
||||
assert_eq!(mail.accounts().len(), 1);
|
||||
});
|
||||
}
|
||||
@@ -4,7 +4,7 @@ use ely_mail_engine::{Auth, Error, Fetched, Key, Protocol, Security, Store, oaut
|
||||
use gpui::{Entity, TestAppContext, VisualTestContext};
|
||||
|
||||
use super::{Keys, account, adding, closed_port, passed, settle, step_words, type_in, window};
|
||||
use crate::{adding::Step, kinds::Kind, mail::Mail};
|
||||
use crate::{adding::Step, boxes::Open, kinds::Kind, mail::Mail};
|
||||
|
||||
#[test]
|
||||
fn an_imap_form_says_what_is_missing() {
|
||||
@@ -188,7 +188,7 @@ fn a_refused_keychain_keeps_the_account_and_says_why() {
|
||||
cx.update(|_, app| {
|
||||
let mail = mail.read(app);
|
||||
assert_eq!(mail.accounts().len(), 1);
|
||||
assert_eq!(mail.picked, Some(mail.accounts()[0].0));
|
||||
assert_eq!(mail.open, Open::Account(mail.accounts()[0].0));
|
||||
assert_eq!(
|
||||
mail.vault
|
||||
.get("account:ann@example.com")
|
||||
@@ -245,6 +245,7 @@ fn an_account_is_kept_and_removed_with_its_secret() {
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), keys.clone());
|
||||
cx.update(|_, app| assert_eq!(mail.read(app).accounts()[0].1, account("ann@example.com")));
|
||||
open_first(&mail, cx);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.ask_remove(cx)));
|
||||
settle(cx, |app| mail.read(app).removing.is_some());
|
||||
cx.update(|_, app| {
|
||||
@@ -272,6 +273,7 @@ fn a_refused_secret_removal_keeps_the_account() {
|
||||
};
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), keys.clone());
|
||||
open_first(&mail, cx);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.ask_remove(cx)));
|
||||
settle(cx, |app| mail.read(app).removing.is_some());
|
||||
press_remove(&mail, cx);
|
||||
@@ -320,6 +322,7 @@ still here
|
||||
.unwrap()
|
||||
.file_name();
|
||||
std::fs::create_dir(shard.join(format!(".{}.gone", name.to_str().unwrap()))).unwrap();
|
||||
open_first(&mail, cx);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.ask_remove(cx)));
|
||||
settle(cx, |app| mail.read(app).removing.is_some());
|
||||
press_remove(&mail, cx);
|
||||
@@ -386,7 +389,7 @@ fn two_saves_in_flight_add_an_address_once() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_keyboard_picks_another_account() {
|
||||
fn the_keyboard_opens_another_accounts_settings() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let store = Store::open(dir.path()).unwrap();
|
||||
store.add_account(&account("ann@example.com")).unwrap();
|
||||
@@ -401,13 +404,13 @@ fn the_keyboard_picks_another_account() {
|
||||
cx.run_until_parked();
|
||||
}
|
||||
for _ in 0..8 {
|
||||
cx.simulate_keystrokes("tab down");
|
||||
cx.simulate_keystrokes("tab space");
|
||||
cx.run_until_parked();
|
||||
if cx.update(|_, app| mail.read(app).picked) == Some(bo) {
|
||||
if cx.update(|_, app| mail.read(app).open) == Open::Account(bo) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
panic!("no Tab stop let Down reach the second account");
|
||||
panic!("no Tab stop let Space open the second account");
|
||||
}
|
||||
|
||||
/// Through the dialog: back to its last stop, Remove.
|
||||
@@ -423,6 +426,13 @@ fn press_remove(mail: &Entity<Mail>, cx: &mut VisualTestContext) {
|
||||
settle(cx, |app| mail.read(app).removing.is_none());
|
||||
}
|
||||
|
||||
/// Opens the first account's page, as a user would.
|
||||
fn open_first(mail: &Entity<Mail>, cx: &mut VisualTestContext) {
|
||||
settle(cx, |app| !mail.read(app).accounts().is_empty());
|
||||
let first = cx.update(|_, app| mail.read(app).accounts()[0].0);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(Open::Account(first), cx)));
|
||||
}
|
||||
|
||||
/// The save lands after a second dialog opened.
|
||||
fn save_then_reopen(fail: bool) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use ely_gpui_component::mail::Mail as Row;
|
||||
use ely_mail_engine::{AccountId, Fetched, Filter, Key, MailboxId, Role, Store};
|
||||
use gpui::{
|
||||
Entity, ScrollDelta, ScrollWheelEvent, SharedString, TestAppContext, VisualTestContext, point,
|
||||
px, size,
|
||||
};
|
||||
|
||||
use super::{Keys, account, settle, window};
|
||||
use crate::{
|
||||
boxes::{self, Open},
|
||||
mail::Mail,
|
||||
};
|
||||
|
||||
fn message(subject: &str, date: &str) -> Vec<u8> {
|
||||
format!(
|
||||
"From: Ann <ann@example.com>\r\nSubject: {subject}\r\nDate: {date}\r\n\
|
||||
Content-Type: text/plain\r\n\r\nhi\r\n"
|
||||
)
|
||||
.into_bytes()
|
||||
}
|
||||
|
||||
fn put(store: &mut Store, mailbox: MailboxId, uid: u32, flags: &[&str], subject: &str, day: u8) {
|
||||
let key = Key::Imap {
|
||||
uidvalidity: 1,
|
||||
uid,
|
||||
};
|
||||
let bytes = message(subject, &format!("{day} Jan 2024 10:00:00 +0000"));
|
||||
store
|
||||
.put(mailbox, &key, flags, Fetched::Whole(&bytes))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// Ann has an inbox and an archive, Bob an inbox.
|
||||
fn seeded(dir: &std::path::Path) -> (AccountId, MailboxId) {
|
||||
let mut store = Store::open(dir).unwrap();
|
||||
let ann = store.add_account(&account("ann@example.com")).unwrap();
|
||||
let bob = store.add_account(&account("bob@example.com")).unwrap();
|
||||
let [ann_inbox, archive] = store
|
||||
.set_folders(
|
||||
ann,
|
||||
&[
|
||||
("INBOX", Some(Role::Inbox)),
|
||||
("Archive", Some(Role::Archive)),
|
||||
],
|
||||
)
|
||||
.unwrap()
|
||||
.try_into()
|
||||
.unwrap();
|
||||
let [bob_inbox] = store
|
||||
.set_folders(bob, &[("INBOX", Some(Role::Inbox))])
|
||||
.unwrap()
|
||||
.try_into()
|
||||
.unwrap();
|
||||
put(&mut store, ann_inbox, 1, &["\\Seen"], "old", 1);
|
||||
put(&mut store, ann_inbox, 2, &[], "new", 3);
|
||||
put(&mut store, archive, 3, &[], "kept", 2);
|
||||
put(&mut store, bob_inbox, 4, &["\\Flagged"], "bob", 2);
|
||||
(ann, archive)
|
||||
}
|
||||
|
||||
/// The listed subjects, once a list is read.
|
||||
fn listed(mail: &Entity<Mail>, cx: &mut VisualTestContext) -> Option<Vec<String>> {
|
||||
cx.update(|_, app| match &mail.read(app).listing.mails {
|
||||
Some(Ok(rows)) => Some(rows.iter().map(|row| row.subject.to_string()).collect()),
|
||||
Some(Err(error)) => panic!("the list failed: {error}"),
|
||||
None => None,
|
||||
})
|
||||
}
|
||||
|
||||
fn shows(mail: &Entity<Mail>, cx: &mut VisualTestContext, subjects: &[&str]) {
|
||||
let want: Vec<String> = subjects.iter().map(|each| each.to_string()).collect();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
||||
while listed(mail, cx).as_ref() != Some(&want) {
|
||||
assert!(
|
||||
std::time::Instant::now() < deadline,
|
||||
"listed {:?}, not {want:?}",
|
||||
listed(mail, cx)
|
||||
);
|
||||
cx.run_until_parked();
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
fn key_of(mail: &Entity<Mail>, cx: &mut VisualTestContext, subject: &str) -> SharedString {
|
||||
cx.update(|_, app| {
|
||||
let mails = mail.read(app).listing.mails.clone();
|
||||
let rows = mails.unwrap().unwrap();
|
||||
rows.iter()
|
||||
.find(|row| row.subject == subject)
|
||||
.unwrap()
|
||||
.key
|
||||
.clone()
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_inbox_is_one_list_newest_first() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
seeded(dir.path());
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
cx.update(|_, app| assert_eq!(mail.read(app).open, Open::Inboxes));
|
||||
shows(&mail, cx, &["new", "bob", "old"]);
|
||||
settle(cx, |app| mail.read(app).inboxes_unread() == 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn filters_narrow_the_list() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
seeded(dir.path());
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
shows(&mail, cx, &["new", "bob", "old"]);
|
||||
let unread = Filter {
|
||||
unread: true,
|
||||
..Filter::default()
|
||||
};
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.set_filter(unread, cx)));
|
||||
shows(&mail, cx, &["new", "bob"]);
|
||||
let flagged = Filter {
|
||||
unread: true,
|
||||
flagged: true,
|
||||
..Filter::default()
|
||||
};
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.set_filter(flagged, cx)));
|
||||
shows(&mail, cx, &["bob"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_folder_lists_its_own_mail() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (ann, archive) = seeded(dir.path());
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
shows(&mail, cx, &["new", "bob", "old"]);
|
||||
let open = Open::Mailbox(ann, archive);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(open, cx)));
|
||||
shows(&mail, cx, &["kept"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_pick_fills_the_reader() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (ann, archive) = seeded(dir.path());
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
shows(&mail, cx, &["new", "bob", "old"]);
|
||||
let (new, bob) = (key_of(&mail, cx, "new"), key_of(&mail, cx, "bob"));
|
||||
let chosen = |cx: &mut VisualTestContext| {
|
||||
cx.update(|_, app| {
|
||||
let chosen = mail.read(app).listing.chosen.as_ref();
|
||||
chosen.map(|row| row.subject.to_string())
|
||||
})
|
||||
};
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.select(std::slice::from_ref(&new), cx)));
|
||||
assert_eq!(chosen(cx).as_deref(), Some("new"));
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.select(&[new, bob], cx)));
|
||||
assert_eq!(chosen(cx), None);
|
||||
let open = Open::Mailbox(ann, archive);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(open, cx)));
|
||||
cx.update(|_, app| assert!(mail.read(app).listing.selected.is_empty()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rebuilt_mailbox_drops_the_pick() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (ann, archive) = seeded(dir.path());
|
||||
// The newest row, whose id SQLite would hand out again.
|
||||
let mut store = Store::open(dir.path()).unwrap();
|
||||
put(&mut store, archive, 9, &[], "picked", 4);
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
let open = Open::Mailbox(ann, archive);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(open, cx)));
|
||||
shows(&mail, cx, &["picked", "kept"]);
|
||||
let picked = key_of(&mail, cx, "picked");
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.select(&[picked], cx)));
|
||||
store.open_mailbox(archive, 2).unwrap();
|
||||
let key = Key::Imap {
|
||||
uidvalidity: 2,
|
||||
uid: 3,
|
||||
};
|
||||
let bytes = message("other", "2 Jan 2024 10:00:00 +0000");
|
||||
store
|
||||
.put(archive, &key, &[], Fetched::Whole(&bytes))
|
||||
.unwrap();
|
||||
drop(store);
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.read_mail(cx)));
|
||||
shows(&mail, cx, &["other"]);
|
||||
cx.update(|_, app| {
|
||||
let listing = &mail.read(app).listing;
|
||||
assert!(listing.selected.is_empty(), "kept {:?}", listing.selected);
|
||||
assert!(listing.chosen.is_none());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picking_every_one_of_many_messages_is_quick() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
shows(&mail, cx, &[]);
|
||||
let rows: Vec<Row> = (0..100_000)
|
||||
.map(|n| Row::undated(n.to_string(), "Ann", "hi"))
|
||||
.collect();
|
||||
let keys: Vec<SharedString> = rows.iter().map(|row| row.key.clone()).collect();
|
||||
let listed = boxes::index(rows);
|
||||
cx.update(|_, app| mail.update(app, |mail, _| mail.listing.show(Some(Ok(listed)))));
|
||||
let started = Instant::now();
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.select(&keys, cx)));
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.select(&keys, cx)));
|
||||
let took = started.elapsed();
|
||||
assert!(took < Duration::from_secs(1), "picking took {took:?}");
|
||||
cx.update(|_, app| assert_eq!(mail.read(app).listing.selected.len(), 100_000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_side_scrolls_past_many_folders_to_the_next_account() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut store = Store::open(dir.path()).unwrap();
|
||||
let ann = store.add_account(&account("ann@example.com")).unwrap();
|
||||
let bob = store.add_account(&account("bob@example.com")).unwrap();
|
||||
let names: Vec<String> = (0..40).map(|n| format!("Folder {n:02}")).collect();
|
||||
let folders: Vec<_> = names.iter().map(|name| (name.as_str(), None)).collect();
|
||||
store.set_folders(ann, &folders).unwrap();
|
||||
store
|
||||
.set_folders(bob, &[("INBOX", Some(Role::Inbox))])
|
||||
.unwrap();
|
||||
drop(store);
|
||||
let mut cx = TestAppContext::single();
|
||||
let (mail, cx) = window(&mut cx, dir.path(), Keys::default());
|
||||
cx.update(|_, app| mail.update(app, |mail, cx| mail.open_box(Open::Account(bob), cx)));
|
||||
cx.simulate_resize(size(px(1100.), px(800.)));
|
||||
settle(cx, |app| {
|
||||
let syncs = &mail.read(app).syncs;
|
||||
syncs.get(&ann).is_some_and(|each| each.folders.len() == 40) && syncs.contains_key(&bob)
|
||||
});
|
||||
let selector = "item-selected-Account settings";
|
||||
let height = cx.update(|window, _| window.viewport_size().height);
|
||||
let before = cx.debug_bounds(selector).expect("Bob's settings row");
|
||||
assert!(before.bottom() > height, "the side fits the window");
|
||||
let at = point(px(100.), height / 2.0);
|
||||
for _ in 0..20 {
|
||||
cx.simulate_event(ScrollWheelEvent {
|
||||
position: at,
|
||||
delta: ScrollDelta::Pixels(point(px(0.), px(-1000.))),
|
||||
..Default::default()
|
||||
});
|
||||
cx.run_until_parked();
|
||||
}
|
||||
let after = cx.debug_bounds(selector).expect("Bob's settings row");
|
||||
assert!(
|
||||
after.bottom() <= height,
|
||||
"Bob's settings are out of reach: {after:?}"
|
||||
);
|
||||
}
|
||||
+11
-13
@@ -9,7 +9,7 @@ use ely_gpui_component::{
|
||||
primitives::{IconName, Severity},
|
||||
typography::format,
|
||||
};
|
||||
use ely_mail_engine::{Account, AccountId, Auth, LocalFolder, Protocol, Security, Server, sync};
|
||||
use ely_mail_engine::{AccountId, Auth, LocalFolder, Protocol, Security, Server, sync};
|
||||
use ely_platform::AppId;
|
||||
use ely_ui::Shell;
|
||||
use gpui::{
|
||||
@@ -18,20 +18,11 @@ use gpui::{
|
||||
};
|
||||
|
||||
use crate::{
|
||||
boxes::Open,
|
||||
mail::{Mail, text},
|
||||
menu,
|
||||
};
|
||||
|
||||
/// "IMAP · imap.example.com"
|
||||
pub fn protocol(account: &Account, cx: &App) -> SharedString {
|
||||
let name = protocol_name(account.protocol);
|
||||
text(
|
||||
cx,
|
||||
"mail.account.line",
|
||||
&[("protocol", name), ("host", &account.incoming.host)],
|
||||
)
|
||||
}
|
||||
|
||||
fn server(server: &Server, cx: &App) -> SharedString {
|
||||
let security = match server.security {
|
||||
Security::Tls => "TLS",
|
||||
@@ -78,10 +69,17 @@ impl Mail {
|
||||
Some(Err(detail)) => return error("mail.store.unread", detail, cx),
|
||||
Some(Ok(accounts)) => accounts,
|
||||
};
|
||||
let Some((id, account)) = accounts.iter().find(|(id, _)| Some(*id) == self.picked) else {
|
||||
if accounts.is_empty() {
|
||||
return EmptyState::new("mail-empty", IconName::Mail, text(cx, "mail.empty", &[]))
|
||||
.action(self.add_button(cx))
|
||||
.into_any_element();
|
||||
}
|
||||
let Open::Account(open) = self.open else {
|
||||
return self.panes(cx);
|
||||
};
|
||||
let Some((id, account)) = accounts.iter().find(|(id, _)| *id == open) else {
|
||||
log::error!("mail: account {} open but not listed", open.0);
|
||||
return error("mail.store.unread", "", cx);
|
||||
};
|
||||
let label = |key: &str| text(cx, key, &[]);
|
||||
let incoming = format!(
|
||||
@@ -272,7 +270,7 @@ impl Render for Mail {
|
||||
}
|
||||
|
||||
/// Local time to the minute.
|
||||
fn local_time(at: i64) -> String {
|
||||
pub fn local_time(at: i64) -> String {
|
||||
match jiff::Timestamp::from_second(at) {
|
||||
Ok(at) => at
|
||||
.to_zoned(jiff::tz::TimeZone::system())
|
||||
|
||||
Reference in new issue
Block a user