From 1e44089d84f32e59c2f8544b00cd60dbaee45b5b Mon Sep 17 00:00:00 2001 From: Manos Pitsidianakis Date: Fri, 26 Apr 2019 11:04:30 +0300 Subject: [PATCH] ui: Refer to child/parents with FolderHash in BackendFolder - use a stack to build folder order list in conf/accounts.rs - update side menu print --- melib/src/mailbox/backends.rs | 11 +- melib/src/mailbox/backends/maildir.rs | 18 ++- melib/src/mailbox/backends/maildir/backend.rs | 66 ++++++---- ui/src/components.rs | 1 - ui/src/components/mail.rs | 117 ++++++++++-------- ui/src/components/mail/view/thread.rs | 62 +--------- ui/src/conf/accounts.rs | 54 +++++--- ui/src/types.rs | 63 ++++++++++ 8 files changed, 233 insertions(+), 159 deletions(-) diff --git a/melib/src/mailbox/backends.rs b/melib/src/mailbox/backends.rs index 738c910c6..a8b792119 100644 --- a/melib/src/mailbox/backends.rs +++ b/melib/src/mailbox/backends.rs @@ -239,12 +239,13 @@ pub trait BackendFolder: Debug { fn name(&self) -> &str; fn change_name(&mut self, new_name: &str); fn clone(&self) -> Folder; - fn children(&self) -> &Vec; + fn children(&self) -> &Vec; + fn parent(&self) -> Option; } #[derive(Debug)] struct DummyFolder { - v: Vec, + v: Vec, } impl BackendFolder for DummyFolder { @@ -262,9 +263,13 @@ impl BackendFolder for DummyFolder { folder_default() } - fn children(&self) -> &Vec { + fn children(&self) -> &Vec { &self.v } + + fn parent(&self) -> Option { + None + } } pub fn folder_default() -> Folder { diff --git a/melib/src/mailbox/backends/maildir.rs b/melib/src/mailbox/backends/maildir.rs index 1f82dee47..8b9c210bc 100644 --- a/melib/src/mailbox/backends/maildir.rs +++ b/melib/src/mailbox/backends/maildir.rs @@ -193,11 +193,17 @@ pub struct MaildirFolder { hash: FolderHash, name: String, path: PathBuf, - children: Vec, + parent: Option, + children: Vec, } impl MaildirFolder { - pub fn new(path: String, file_name: String, children: Vec) -> Result { + pub fn new( + path: String, + file_name: String, + parent: Option, + children: Vec, + ) -> Result { let pathbuf = PathBuf::from(path); let mut h = DefaultHasher::new(); pathbuf.hash(&mut h); @@ -206,6 +212,7 @@ impl MaildirFolder { hash: h.finish(), name: file_name, path: pathbuf, + parent, children, }; ret.is_valid()?; @@ -243,7 +250,7 @@ impl BackendFolder for MaildirFolder { self.name = s.to_string(); } - fn children(&self) -> &Vec { + fn children(&self) -> &Vec { &self.children } @@ -253,6 +260,11 @@ impl BackendFolder for MaildirFolder { name: self.name.clone(), path: self.path.clone(), children: self.children.clone(), + parent: self.parent.clone(), }) } + + fn parent(&self) -> Option { + self.parent.clone() + } } diff --git a/melib/src/mailbox/backends/maildir/backend.rs b/melib/src/mailbox/backends/maildir/backend.rs index 9699a8bd5..b007d6609 100644 --- a/melib/src/mailbox/backends/maildir/backend.rs +++ b/melib/src/mailbox/backends/maildir/backend.rs @@ -73,7 +73,7 @@ pub type HashIndexes = Arc>>; #[derive(Debug)] pub struct MaildirType { name: String, - folders: Vec, + folders: FnvHashMap, //folder_index: FnvHashMap, hash_indexes: HashIndexes, path: PathBuf, @@ -144,7 +144,10 @@ fn move_to_cur(p: PathBuf) -> PathBuf { impl MailBackend for MaildirType { fn folders(&self) -> FnvHashMap { - self.folders.iter().map(|f| (f.hash(), f.clone())).collect() + self.folders + .iter() + .map(|(h, f)| (*h, f.clone() as Folder)) + .collect() } fn get(&mut self, folder: &Folder) -> Async>> { self.multicore(4, folder) @@ -417,7 +420,7 @@ eprintln!("removed but not contained in index"); } fn save(&self, bytes: &[u8], folder: &str) -> Result<()> { - for f in &self.folders { + for f in self.folders.values() { if f.name == folder { let mut path = f.path.clone(); path.push("cur"); @@ -464,25 +467,34 @@ eprintln!("removed but not contained in index"); impl MaildirType { pub fn new(f: &AccountSettings) -> Self { - let mut folders: Vec = Vec::new(); - fn recurse_folders>(folders: &mut Vec, p: P) -> Vec { + let name = f.name.clone(); + let mut folders: FnvHashMap = Default::default(); + fn recurse_folders>( + folders: &mut FnvHashMap, + p: P, + ) -> Vec { let mut children = Vec::new(); for mut f in fs::read_dir(p).unwrap() { - for f in f.iter_mut() { + 'entries: for f in f.iter_mut() { { let path = f.path(); if path.ends_with("cur") || path.ends_with("new") || path.ends_with("tmp") { - continue; + continue 'entries; } if path.is_dir() { - let path_children = recurse_folders(folders, &path); + let path_children = std::dbg!(recurse_folders(folders, &path)); if let Ok(f) = MaildirFolder::new( path.to_str().unwrap().to_string(), path.file_name().unwrap().to_str().unwrap().to_string(), + None, path_children, ) { - folders.push(f); - children.push(folders.len() - 1); + f.children + .iter() + .map(|c| folders.get_mut(c).map(|f| f.parent = Some(f.hash))) + .count(); + children.push(f.hash); + folders.insert(f.hash, f); } } } @@ -495,18 +507,28 @@ impl MaildirType { if let Ok(f) = MaildirFolder::new( path.to_str().unwrap().to_string(), path.file_name().unwrap().to_str().unwrap().to_string(), + None, Vec::with_capacity(0), ) { - if f.is_valid().is_ok() { - folders.push(f); - } + let l: MaildirFolder = f; + folders.insert(l.hash, l); } } if folders.is_empty() { - recurse_folders(&mut folders, &path); + let children = recurse_folders(&mut folders, &path); + children + .iter() + .map(|c| folders.get_mut(c).map(|f| f.parent = None)) + .count(); } else { - folders[0].children = recurse_folders(&mut folders, &path); + let root_hash = *folders.keys().nth(0).unwrap(); + let children = recurse_folders(&mut folders, &path); + children + .iter() + .map(|c| folders.get_mut(c).map(|f| f.parent = Some(root_hash))) + .count(); + folders.get_mut(&root_hash).map(|f| f.children = children); } let hash_indexes = Arc::new(Mutex::new(FnvHashMap::with_capacity_and_hasher( @@ -515,12 +537,12 @@ impl MaildirType { ))); { let mut hash_indexes = hash_indexes.lock().unwrap(); - for f in &folders { + for &fh in folders.keys() { hash_indexes.insert( - f.hash(), + fh, HashIndex { index: FnvHashMap::with_capacity_and_hasher(0, Default::default()), - hash: f.hash(), + hash: fh, }, ); } @@ -532,10 +554,10 @@ impl MaildirType { path: PathBuf::from(f.root_folder()), } } - fn owned_folder_idx(&self, folder: &Folder) -> usize { - self.folders + fn owned_folder_idx(&self, folder: &Folder) -> FolderHash { + *self + .folders .iter() - .enumerate() .find(|(_, f)| f.hash() == folder.hash()) .unwrap() .0 @@ -548,7 +570,7 @@ impl MaildirType { let handle = { let tx = w.tx(); // TODO: Avoid clone - let folder: &MaildirFolder = &self.folders[self.owned_folder_idx(folder)]; + let folder: &MaildirFolder = &self.folders[&self.owned_folder_idx(folder)]; let folder_hash = folder.hash(); let tx_final = w.tx(); let path: PathBuf = folder.path().into(); diff --git a/ui/src/components.rs b/ui/src/components.rs index 96a70b246..1dd9cf64e 100644 --- a/ui/src/components.rs +++ b/ui/src/components.rs @@ -43,7 +43,6 @@ pub use contacts::*; use std::fmt; use std::fmt::{Debug, Display}; -use std::ops::{Deref, DerefMut}; use fnv::FnvHashMap; use uuid::Uuid; diff --git a/ui/src/components/mail.rs b/ui/src/components/mail.rs index f57fcf503..be53b820f 100644 --- a/ui/src/components/mail.rs +++ b/ui/src/components/mail.rs @@ -23,6 +23,7 @@ */ use super::*; use melib::backends::Folder; +use melib::backends::FolderHash; pub mod listing; pub use listing::*; @@ -91,35 +92,23 @@ impl AccountMenu { eprintln!("BUG: invalid area in print_account"); } // Each entry and its index in the account - let entries: Vec<(usize, Folder)> = { - let a = &context.accounts[a.index]; - let mut entries = Vec::with_capacity(a.len()); - for (idx, acc) in a.list_folders().into_iter().enumerate() { - entries.push((idx, acc)); - } - entries - }; + let entries: FnvHashMap = context.accounts[a.index] + .list_folders() + .into_iter() + .map(|f| (f.hash(), f)) + .collect(); + let folders_order: FnvHashMap = context.accounts[a.index] + .folders_order() + .iter() + .enumerate() + .map(|(i, &fh)| (fh, i)) + .collect(); + let upper_left = upper_left!(area); let bottom_right = bottom_right!(area); let highlight = self.cursor.map(|(x, _)| x == a.index).unwrap_or(false); - let mut parents: Vec> = vec![None; entries.len()]; - - for (idx, e) in entries.iter().enumerate() { - for &c in e.1.children() { - if c < parents.len() { - parents[c] = Some(idx); - } - } - } - let mut roots = Vec::new(); - for (idx, c) in parents.iter().enumerate() { - if c.is_none() { - roots.push(idx); - } - } - let mut inc = 0; let mut depth = String::from(""); let mut s = format!("{}\n", a.name); @@ -133,50 +122,72 @@ impl AccountMenu { } fn print( - root: usize, - parents: &[Option], + folder_idx: FolderHash, depth: &mut String, - entries: &[(usize, Folder)], - s: &mut String, inc: &mut usize, + entries: &FnvHashMap, + folders_order: &FnvHashMap, + s: &mut String, index: usize, //account index context: &mut Context, ) { - if root >= entries.len() { - return; - } - let len = s.len(); - match context.accounts[index].status(entries[root].1.hash()) { - Ok(_) => {} + match context.accounts[index].status(entries[&folder_idx].hash()) { + Ok(_) => { + let count = context.accounts[index][entries[&folder_idx].hash()] + .as_ref() + .unwrap() + .collection + .values() + .filter(|e| !e.is_seen()) + .count(); + let len = s.len(); + s.insert_str( + len, + &format!("{} {} {}\n ", *inc, &entries[&folder_idx].name(), count), + ); + } Err(_) => { - return; - // TODO: Show progress visually + let len = s.len(); + s.insert_str( + len, + &format!("{} {} ...\n ", *inc, &entries[&folder_idx].name()), + ); } } - let count = context.accounts[index][root] - .as_ref() - .unwrap() - .collection - .values() - .filter(|e| !e.is_seen()) - .count(); - s.insert_str( - len, - &format!("{} {} {}\n ", *inc, &entries[root].1.name(), count), - ); *inc += 1; - for child in entries[root].1.children().iter() { + let mut children: Vec = entries[&folder_idx].children().to_vec(); + children + .sort_unstable_by(|a, b| folders_order[a].partial_cmp(&folders_order[b]).unwrap()); + for child in entries[&folder_idx].children().iter() { let len = s.len(); s.insert_str(len, &format!("{} ", depth)); push(depth, ' '); - print(*child, parents, depth, entries, s, inc, index, context); + print( + *child, + depth, + inc, + entries, + folders_order, + s, + index, + context, + ); pop(depth); } } - for r in roots { - print( - r, &parents, &mut depth, &entries, &mut s, &mut inc, a.index, context, - ); + for f in entries.keys() { + if entries[f].parent().is_none() { + print( + *f, + &mut depth, + &mut inc, + &entries, + &folders_order, + &mut s, + a.index, + context, + ); + } } let lines: Vec<&str> = s.lines().collect(); diff --git a/ui/src/components/mail/view/thread.rs b/ui/src/components/mail/view/thread.rs index 81e9ca66a..2b591dfc4 100644 --- a/ui/src/components/mail/view/thread.rs +++ b/ui/src/components/mail/view/thread.rs @@ -54,63 +54,6 @@ pub struct ThreadView { id: ComponentId, } -#[derive(Debug)] -struct StackVec { - len: usize, - array: [usize; 8], - heap_vec: Vec, -} - -impl StackVec { - fn new() -> Self { - StackVec { - len: 0, - array: [0, 0, 0, 0, 0, 0, 0, 0], - heap_vec: Vec::new(), - } - } - fn push(&mut self, ind: usize) { - if self.len == self.array.len() { - self.heap_vec.clear(); - self.heap_vec.reserve(16); - self.heap_vec.copy_from_slice(&self.array); - self.heap_vec.push(ind); - } else if self.len > self.array.len() { - self.heap_vec.push(ind); - } else { - self.array[self.len] = ind; - } - self.len += 1; - } - fn pop(&mut self) -> usize { - if self.len >= self.array.len() { - self.heap_vec.pop().unwrap() - } else { - let ret = self.array[self.len]; - self.len = self.len.saturating_sub(1); - ret - } - } - fn len(&self) -> usize { - self.len - } - fn is_empty(&self) -> bool { - self.len == 0 - } -} - -impl Index for StackVec { - type Output = usize; - - fn index(&self, idx: usize) -> &usize { - if self.len >= self.array.len() { - &self.heap_vec[idx] - } else { - &self.array[idx] - } - } -} - impl ThreadView { /* * coordinates: (account index, mailbox index, root set thread_node index) @@ -133,7 +76,8 @@ impl ThreadView { cursor_pos: 1, new_cursor_pos: 0, dirty: true, - id: ComponentId::new_v4(), ..Default::default() + id: ComponentId::new_v4(), + ..Default::default() }; view.initiate(expanded_idx, context); view.new_cursor_pos = view.new_expanded_pos; @@ -875,7 +819,7 @@ impl Component for ThreadView { .operation(envelope.hash(), mailbox.folder.hash()); if cfg!(debug_assertions) { eprint!("{}:{}_{}: ", file!(), line!(), column!()); -eprintln!( + eprintln!( "sending action edit for {}, {}", envelope.message_id(), op.description() diff --git a/ui/src/conf/accounts.rs b/ui/src/conf/accounts.rs index b7d00dc15..b38bded1f 100644 --- a/ui/src/conf/accounts.rs +++ b/ui/src/conf/accounts.rs @@ -24,6 +24,7 @@ */ use super::AccountConf; +use crate::StackVec; use fnv::FnvHashMap; use melib::async_workers::{Async, AsyncBuilder, AsyncStatus}; use melib::backends::FolderHash; @@ -69,7 +70,7 @@ pub struct Account { pub(crate) settings: AccountConf, pub(crate) runtime_settings: AccountConf, - pub(crate) backend: Box, + pub(crate) backend: Box, notify_fn: Arc, } @@ -128,19 +129,10 @@ impl Account { let mut ref_folders: FnvHashMap = backend.folders(); let mut folders: FnvHashMap>> = FnvHashMap::with_capacity_and_hasher(ref_folders.len(), Default::default()); - let mut folders_order: Vec = ref_folders.values().map(|f| f.hash()).collect(); + let mut folders_order: Vec = Vec::with_capacity(folders.len()); let mut workers: FnvHashMap = FnvHashMap::default(); let notify_fn = Arc::new(notify_fn); - if let Some(pos) = ref_folders - .values() - .position(|f| f.name().eq_ignore_ascii_case("INBOX")) - { - folders_order.swap(pos, 0); - } - let sent_folder = ref_folders - .values() - .position(|x: &Folder| x.name() == settings.account().sent_folder); if let Some(folder_confs) = settings.conf().folders() { //if cfg!(debug_assertions) { //eprint!("{}:{}_{}: ", file!(), line!(), column!()); @@ -154,10 +146,28 @@ impl Account { } } } - for (h, f) in ref_folders.into_iter() { - folders.insert(h, None); - workers.insert(h, Account::new_worker(f, &mut backend, notify_fn.clone())); + let mut stack: StackVec = StackVec::new(); + for (h, f) in ref_folders.iter() { + if f.parent().is_none() { + folders_order.push(f.hash()); + for &c in f.children() { + stack.push(c); + } + while !stack.is_empty() { + let next = stack.pop(); + folders_order.push(next); + for c in ref_folders[&next].children() { + stack.push(*c); + } + } + } + folders.insert(*h, None); + workers.insert( + *h, + Account::new_worker(f.clone(), &mut backend, notify_fn.clone()), + ); } + let data_dir = xdg::BaseDirectories::with_profile("meli", &name).unwrap(); let address_book = if let Ok(data) = data_dir.place_data_file("addressbook") { if data.exists() { @@ -180,7 +190,7 @@ impl Account { folders, folders_order, address_book, - sent_folder, + sent_folder: None, workers, settings: settings.clone(), runtime_settings: settings, @@ -295,10 +305,18 @@ impl Account { folders.swap(pos, 0); } */ - self.folders_order + let order: FnvHashMap = self + .folders_order .iter() - .map(|ref h| folders.remove(&h).unwrap()) - .collect() + .enumerate() + .map(|(i, &fh)| (fh, i)) + .collect(); + let mut folders: Vec = folders.drain().map(|(_, f)| f).collect(); + folders.sort_unstable_by(|a, b| order[&a.hash()].partial_cmp(&order[&b.hash()]).unwrap()); + folders + } + pub fn folders_order(&self) -> &Vec { + &self.folders_order } pub fn name(&self) -> &str { &self.name diff --git a/ui/src/types.rs b/ui/src/types.rs index 1cb8378e5..2521c3462 100644 --- a/ui/src/types.rs +++ b/ui/src/types.rs @@ -31,6 +31,7 @@ use melib::EnvelopeHash; use melib::RefreshEvent; use std; use std::fmt; +use std::ops::Index; use std::thread; use uuid::Uuid; @@ -128,3 +129,65 @@ pub struct Notification { _timestamp: std::time::Instant, } + +#[derive(Debug)] +pub(crate) struct StackVec { + len: usize, + array: [T; 8], + heap_vec: Vec, +} + +impl StackVec { + pub(crate) fn new() -> Self { + StackVec { + len: 0, + array: [T::default(); 8], + heap_vec: Vec::new(), + } + } + pub(crate) fn push(&mut self, ind: T) { + if self.len == self.array.len() { + if self.heap_vec.is_empty() { + self.heap_vec.reserve(16); + for _ in 0..8 { + self.heap_vec.push(T::default()); + } + } + self.heap_vec[0..8].copy_from_slice(&self.array); + self.heap_vec.push(ind); + } else if self.len > self.array.len() { + self.heap_vec.push(ind); + } else { + self.array[self.len] = ind; + } + self.len += 1; + } + pub(crate) fn pop(&mut self) -> T { + if self.len >= self.array.len() { + self.len -= 1; + self.heap_vec.pop().unwrap() + } else { + let ret = self.array[self.len - 1]; + self.len = self.len - 1; + ret + } + } + pub(crate) fn len(&self) -> usize { + self.len + } + pub(crate) fn is_empty(&self) -> bool { + self.len == 0 + } +} + +impl Index for StackVec { + type Output = T; + + fn index(&self, idx: usize) -> &T { + if self.len >= self.array.len() { + &self.heap_vec[idx] + } else { + &self.array[idx] + } + } +}