llange
/
meli
forked from meli/meli
1
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Rename all getters from get_X to X 

closes #5
embed
Manos Pitsidianakis 2018-07-20 12:44:04 +03:00
parent 8c98d3a5a0
commit 0092496632
Signed by: Manos Pitsidianakis
GPG Key ID: 73627C2F690DF710
15 changed files with 291 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
melib/src/conf/mod.rs
View File

@ -54,13 +54,13 @@ impl Folder {
children: children, children: children,
} }
} }
pub fn get_path(&self) -> &str { pub fn path(&self) -> &str {
&self.path &self.path
} }
pub fn get_name(&self) -> &str { pub fn name(&self) -> &str {
&self.name &self.name
} }
pub fn get_children(&self) -> &Vec<usize> { pub fn children(&self) -> &Vec<usize> {
&self.children &self.children
} }
} }
@ -91,10 +91,10 @@ pub struct AccountSettings {
} }
impl AccountSettings { impl AccountSettings {
pub fn get_format(&self) -> &str { pub fn format(&self) -> &str {
&self.format &self.format
} }
pub fn get_name(&self) -> &str { pub fn name(&self) -> &str {
&self.name &self.name
} }
} }

8
melib/src/mailbox/accounts.rs
View File

@ -41,12 +41,12 @@ impl Account {
let sent_folder = settings let sent_folder = settings
.folders .folders
.iter() .iter()
.position(|x| *x.get_path() == settings.sent_folder); .position(|x| *x.path() == settings.sent_folder);
let mut folders = Vec::with_capacity(settings.folders.len()); let mut folders = Vec::with_capacity(settings.folders.len());
for _ in 0..settings.folders.len() { for _ in 0..settings.folders.len() {
folders.push(None); folders.push(None);
} }
let backend = backends.get(settings.get_format()); let backend = backends.get(settings.format());
Account { Account {
name: name, name: name,
folders: folders, folders: folders,
@ -67,7 +67,7 @@ impl Account {
pub fn list_folders(&self) -> Vec<Folder> { pub fn list_folders(&self) -> Vec<Folder> {
self.settings.folders.clone() self.settings.folders.clone()
} }
pub fn get_name(&self) -> &str { pub fn name(&self) -> &str {
&self.name &self.name
} }
} }
@ -83,7 +83,7 @@ impl IndexMut<usize> for Account {
fn index_mut(&mut self, index: usize) -> &mut Option<Result<Mailbox>> { fn index_mut(&mut self, index: usize) -> &mut Option<Result<Mailbox>> {
if self.folders[index].is_none() { if self.folders[index].is_none() {
let folder = &self.settings.folders[index]; let folder = &self.settings.folders[index];
let path = folder.get_path().clone(); let path = folder.path().clone();
if self.sent_folder.is_some() { if self.sent_folder.is_some() {
let id = self.sent_folder.unwrap(); let id = self.sent_folder.unwrap();
if id == index { if id == index {

12
melib/src/mailbox/backends/maildir.rs
View File

@ -124,7 +124,7 @@ pub struct MaildirType {
impl MailBackend for MaildirType { impl MailBackend for MaildirType {
fn get(&self, folder: &Folder) -> Result<Vec<Envelope>> { fn get(&self, folder: &Folder) -> Result<Vec<Envelope>> {
self.get_multicore(4, folder) self.multicore(4, folder)
} }
fn watch(&self, sender: RefreshEventConsumer, folders: &[Folder]) -> () { fn watch(&self, sender: RefreshEventConsumer, folders: &[Folder]) -> () {
let folders = folders.to_vec(); let folders = folders.to_vec();
@ -136,7 +136,7 @@ impl MailBackend for MaildirType {
if MaildirType::is_valid(&f).is_err() { if MaildirType::is_valid(&f).is_err() {
continue; continue;
} }
let mut p = PathBuf::from(&f.get_path()); let mut p = PathBuf::from(&f.path());
p.push("cur"); p.push("cur");
watcher.watch(&p, RecursiveMode::NonRecursive).unwrap(); watcher.watch(&p, RecursiveMode::NonRecursive).unwrap();
p.pop(); p.pop();
@ -167,7 +167,7 @@ impl MaildirType {
} }
} }
fn is_valid(f: &Folder) -> Result<()> { fn is_valid(f: &Folder) -> Result<()> {
let path = f.get_path(); let path = f.path();
let mut p = PathBuf::from(path); let mut p = PathBuf::from(path);
for d in &["cur", "new", "tmp"] { for d in &["cur", "new", "tmp"] {
p.push(d); p.push(d);
@ -180,9 +180,9 @@ impl MaildirType {
} }
Ok(()) Ok(())
} }
pub fn get_multicore(&self, cores: usize, folder: &Folder) -> Result<Vec<Envelope>> { pub fn multicore(&self, cores: usize, folder: &Folder) -> Result<Vec<Envelope>> {
MaildirType::is_valid(folder)?; MaildirType::is_valid(folder)?;
let path = folder.get_path(); let path = folder.path();
let mut path = PathBuf::from(path); let mut path = PathBuf::from(path);
path.push("cur"); path.push("cur");
let iter = path.read_dir()?; let iter = path.read_dir()?;
@ -209,7 +209,7 @@ impl MaildirType {
let mut local_r: Vec<Envelope> = Vec::with_capacity(chunk.len()); let mut local_r: Vec<Envelope> = Vec::with_capacity(chunk.len());
for e in chunk { for e in chunk {
let e_copy = e.to_string(); let e_copy = e.to_string();
if let Some(mut e) = Envelope::from(Box::new(BackendOpGenerator::new( if let Some(mut e) = Envelope::from_token(Box::new(BackendOpGenerator::new(
Box::new(move || Box::new(MaildirOp::new(e_copy.clone()))), Box::new(move || Box::new(MaildirOp::new(e_copy.clone()))),
))) { ))) {
e.populate_headers(); e.populate_headers();

10
melib/src/mailbox/email/attachments.rs
View File

@ -275,7 +275,7 @@ impl Attachment {
fn get_text_recursive(&self, text: &mut String) { fn get_text_recursive(&self, text: &mut String) {
match self.attachment_type { match self.attachment_type {
AttachmentType::Data { .. } => { AttachmentType::Data { .. } => {
text.push_str(&format!("Data attachment of type {}", self.get_tag())); text.push_str(&format!("Data attachment of type {}", self.tag()));
} }
AttachmentType::Text { content: ref t } => { AttachmentType::Text { content: ref t } => {
text.push_str(t); text.push_str(t);
@ -298,19 +298,19 @@ impl Attachment {
}, },
} }
} }
pub fn get_text(&self) -> String { pub fn text(&self) -> String {
let mut text = String::with_capacity(self.raw.len()); let mut text = String::with_capacity(self.raw.len());
self.get_text_recursive(&mut text); self.get_text_recursive(&mut text);
text text
} }
pub fn get_description(&self) -> String { pub fn description(&self) -> String {
unimplemented!() unimplemented!()
} }
pub fn get_tag(&self) -> String { pub fn tag(&self) -> String {
format!("{}/{}", self.content_type.0, self.content_type.1).to_string() format!("{}/{}", self.content_type.0, self.content_type.1).to_string()
} }
pub fn count_attachments(&mut self) -> usize { pub fn count_attachments(&mut self) -> usize {
let mut counter = 0; let mut counter = 0;
fn count_recursive(att: &Attachment, counter: &mut usize) { fn count_recursive(att: &Attachment, counter: &mut usize) {
match att.attachment_type { match att.attachment_type {

372
melib/src/mailbox/email/mod.rs
View File

@ -46,9 +46,9 @@ pub trait StrBuild {
/// Create a new `Self` out of a string and a slice /// Create a new `Self` out of a string and a slice
fn new(string: &str, slice: &str) -> Self; fn new(string: &str, slice: &str) -> Self;
/// Get the slice part of the string /// Get the slice part of the string
fn get_raw(&self) -> &str; fn raw(&self) -> &str;
/// Get the entire string as a slice /// Get the entire string as a slice
fn get_val(&self) -> &str; fn val(&self) -> &str;
} }
/// `MessageID` is accessed through the `StrBuild` trait. /// `MessageID` is accessed through the `StrBuild` trait.
@ -64,14 +64,14 @@ impl StrBuild for MessageID {
offset: offset, offset: offset,
length: slice.len() + 1, length: slice.len() + 1,
}, },
) )
} }
fn get_raw(&self) -> &str { fn raw(&self) -> &str {
let offset = self.1.offset; let offset = self.1.offset;
let length = self.1.length; let length = self.1.length;
&self.0[offset..length] &self.0[offset..length]
} }
fn get_val(&self) -> &str { fn val(&self) -> &str {
&self.0 &self.0
} }
} }
@ -88,18 +88,18 @@ fn test_strbuilder() {
offset: 1, offset: 1,
length: 43, length: 43,
} }
) )
); );
} }
impl PartialEq for MessageID { impl PartialEq for MessageID {
fn eq(&self, other: &MessageID) -> bool { fn eq(&self, other: &MessageID) -> bool {
self.get_raw() == other.get_raw() self.raw() == other.raw()
} }
} }
impl fmt::Debug for MessageID { impl fmt::Debug for MessageID {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.get_raw()) write!(f, "{}", self.raw())
} }
} }
@ -124,7 +124,7 @@ bitflags! {
/// `Envelope` represents all the data of an email we need to know. /// `Envelope` represents all the data of an email we need to know.
/// ///
/// Attachments (the email's body) is parsed on demand with `get_body`. /// Attachments (the email's body) is parsed on demand with `body`.
/// ///
/// Access to the underlying email object in the account's backend (for example the file or the /// Access to the underlying email object in the account's backend (for example the file or the
/// entry in an IMAP server) is given through `operation_token`. For more information see /// entry in an IMAP server) is given through `operation_token`. For more information see
@ -171,7 +171,7 @@ impl Envelope {
flags: Flag::default(), flags: Flag::default(),
} }
} }
pub fn from(operation_token: Box<BackendOpGenerator>) -> Option<Envelope> { pub fn from_token(operation_token: Box<BackendOpGenerator>) -> Option<Envelope> {
let operation = operation_token.generate(); let operation = operation_token.generate();
let mut e = Envelope::new(operation_token); let mut e = Envelope::new(operation_token);
e.flags = operation.fetch_flags(); e.flags = operation.fetch_flags();
@ -243,7 +243,7 @@ impl Envelope {
/* /*
* https://tools.ietf.org/html/rfc5322#section-3.6.4 * https://tools.ietf.org/html/rfc5322#section-3.6.4
* *
* if self.message_id.is_none() { ... * if self.message_id.is_none() ...
*/ */
if let Some(ref mut x) = in_reply_to { if let Some(ref mut x) = in_reply_to {
self.push_references(x); self.push_references(x);
@ -254,200 +254,200 @@ if let Some(ref mut d) = datetime {
} }
} }
} }
pub fn get_date(&self) -> i64 { pub fn date(&self) -> i64 {
self.timestamp self.timestamp
}
pub fn datetime(&self) -> chrono::DateTime<chrono::FixedOffset> {
self.datetime.unwrap_or_else(|| {
chrono::FixedOffset::west(0)
.ymd(1970, 1, 1)
.and_hms(0, 0, 0)
})
}
pub fn date_as_str(&self) -> &str {
&self.date
}
pub fn from(&self) -> &str {
match self.from {
Some(ref s) => s,
None => "",
} }
pub fn get_datetime(&self) -> chrono::DateTime<chrono::FixedOffset> { }
self.datetime.unwrap_or_else(|| { pub fn to(&self) -> &str {
chrono::FixedOffset::west(0) match self.to {
.ymd(1970, 1, 1) Some(ref s) => s,
.and_hms(0, 0, 0) None => "",
})
} }
pub fn get_date_as_str(&self) -> &str { }
&self.date pub fn body(&self) -> Attachment {
} let mut operation = self.operation_token.generate();
pub fn get_from(&self) -> &str { let file = operation.as_bytes();
match self.from { let (headers, body) = match parser::mail(file.unwrap()).to_full_result() {
Some(ref s) => s, Ok(v) => v,
None => "", Err(_) => {
let operation = self.operation_token.generate();
eprintln!("error in parsing mail\n{}", operation.description());
panic!()
}
};
let mut builder = AttachmentBuilder::new(body);
for (name, value) in headers {
if value.len() == 1 && value.is_empty() {
continue;
}
if name.eq_ignore_ascii_case("content-transfer-encoding") {
builder.content_transfer_encoding(value);
} else if name.eq_ignore_ascii_case("content-type") {
builder.content_type(value);
} }
} }
pub fn get_to(&self) -> &str { builder.build()
match self.to { }
Some(ref s) => s, pub fn subject(&self) -> &str {
None => "", match self.subject {
Some(ref s) => s,
_ => "",
}
}
pub fn in_reply_to(&self) -> &str {
match self.in_reply_to {
Some(ref s) => s.val(),
_ => "",
}
}
pub fn in_reply_to_raw(&self) -> &str {
match self.in_reply_to {
Some(ref s) => s.raw(),
_ => "",
}
}
pub fn message_id(&self) -> &str {
match self.message_id {
Some(ref s) => s.val(),
_ => "",
}
}
pub fn message_id_raw(&self) -> &str {
match self.message_id {
Some(ref s) => s.raw(),
_ => "",
}
}
fn set_date(&mut self, new_val: String) -> () {
self.date = new_val;
}
fn set_from(&mut self, new_val: String) -> () {
self.from = Some(new_val);
}
fn set_to(&mut self, new_val: String) -> () {
self.to = Some(new_val);
}
fn set_in_reply_to(&mut self, new_val: &str) -> () {
let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
Ok(v) => v,
Err(v) => {
self.in_reply_to = None;
return;
} }
} };
pub fn get_body(&self) -> Attachment { self.in_reply_to = Some(MessageID::new(new_val, slice));
let mut operation = self.operation_token.generate(); }
let file = operation.as_bytes(); fn set_subject(&mut self, new_val: String) -> () {
let (headers, body) = match parser::mail(file.unwrap()).to_full_result() { self.subject = Some(new_val);
Ok(v) => v, }
Err(_) => { fn set_message_id(&mut self, new_val: &str) -> () {
let operation = self.operation_token.generate(); let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
eprintln!("error in parsing mail\n{}", operation.description()); Ok(v) => v,
panic!() Err(v) => {
} self.message_id = None;
}; return;
let mut builder = AttachmentBuilder::new(body);
for (name, value) in headers {
if value.len() == 1 && value.is_empty() {
continue;
}
if name.eq_ignore_ascii_case("content-transfer-encoding") {
builder.content_transfer_encoding(value);
} else if name.eq_ignore_ascii_case("content-type") {
builder.content_type(value);
}
} }
builder.build() };
} self.message_id = Some(MessageID::new(new_val, slice));
pub fn get_subject(&self) -> &str { }
match self.subject { fn push_references(&mut self, new_val: &str) -> () {
Some(ref s) => s, let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
_ => "", Ok(v) => v,
Err(v) => {
return;
} }
} };
pub fn get_in_reply_to(&self) -> &str { let new_ref = MessageID::new(new_val, slice);
match self.in_reply_to { match self.references {
Some(ref s) => s.get_val(), Some(ref mut s) => {
_ => "", if s.refs.contains(&new_ref) {
} if s.refs[s.refs.len() - 1] != new_ref {
} if let Some(index) = s.refs.iter().position(|x| *x == new_ref) {
pub fn get_in_reply_to_raw(&self) -> &str { s.refs.remove(index);
match self.in_reply_to {
Some(ref s) => s.get_raw(),
_ => "",
}
}
pub fn get_message_id(&self) -> &str {
match self.message_id {
Some(ref s) => s.get_val(),
_ => "",
}
}
pub fn get_message_id_raw(&self) -> &str {
match self.message_id {
Some(ref s) => s.get_raw(),
_ => "",
}
}
fn set_date(&mut self, new_val: String) -> () {
self.date = new_val;
}
fn set_from(&mut self, new_val: String) -> () {
self.from = Some(new_val);
}
fn set_to(&mut self, new_val: String) -> () {
self.to = Some(new_val);
}
fn set_in_reply_to(&mut self, new_val: &str) -> () {
let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
Ok(v) => v,
Err(v) => {
self.in_reply_to = None;
return;
}
};
self.in_reply_to = Some(MessageID::new(new_val, slice));
}
fn set_subject(&mut self, new_val: String) -> () {
self.subject = Some(new_val);
}
fn set_message_id(&mut self, new_val: &str) -> () {
let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
Ok(v) => v,
Err(v) => {
self.message_id = None;
return;
}
};
self.message_id = Some(MessageID::new(new_val, slice));
}
fn push_references(&mut self, new_val: &str) -> () {
let slice = match parser::message_id(new_val.as_bytes()).to_full_result() {
Ok(v) => v,
Err(v) => {
return;
}
};
let new_ref = MessageID::new(new_val, slice);
match self.references {
Some(ref mut s) => {
if s.refs.contains(&new_ref) {
if s.refs[s.refs.len() - 1] != new_ref {
if let Some(index) = s.refs.iter().position(|x| *x == new_ref) {
s.refs.remove(index);
} else {
panic!();
}
} else { } else {
return; panic!();
} }
} else {
return;
} }
s.refs.push(new_ref);
}
None => {
let mut v = Vec::new();
v.push(new_ref);
self.references = Some(References {
raw: "".to_string(),
refs: v,
});
} }
s.refs.push(new_ref);
}
None => {
let mut v = Vec::new();
v.push(new_ref);
self.references = Some(References {
raw: "".to_string(),
refs: v,
});
} }
} }
fn set_references(&mut self, new_val: String) -> () { }
match self.references { fn set_references(&mut self, new_val: String) -> () {
Some(ref mut s) => { match self.references {
s.raw = new_val; Some(ref mut s) => {
} s.raw = new_val;
None => { }
let v = Vec::new(); None => {
self.references = Some(References { let v = Vec::new();
raw: new_val, self.references = Some(References {
refs: v, raw: new_val,
}); refs: v,
} });
} }
} }
pub fn get_references(&self) -> Vec<&MessageID> { }
match self.references { pub fn references(&self) -> Vec<&MessageID> {
Some(ref s) => s.refs match self.references {
.iter() Some(ref s) => s.refs
.fold(Vec::with_capacity(s.refs.len()), |mut acc, x| { .iter()
acc.push(x); .fold(Vec::with_capacity(s.refs.len()), |mut acc, x| {
acc acc.push(x);
}), acc
None => Vec::new(), }),
} None => Vec::new(),
}
pub fn set_body(&mut self, new_val: Attachment) -> () {
self.body = Some(new_val);
}
pub fn get_thread(&self) -> usize {
self.thread
}
pub fn set_thread(&mut self, new_val: usize) -> () {
self.thread = new_val;
}
pub fn set_datetime(&mut self, new_val: chrono::DateTime<chrono::FixedOffset>) -> () {
self.datetime = Some(new_val);
self.timestamp = new_val.timestamp();
}
pub fn get_flags(&self) -> Flag {
self.flags
}
pub fn is_seen(&self) -> bool {
!(self.flags & Flag::SEEN).is_empty()
} }
} }
pub fn set_body(&mut self, new_val: Attachment) -> () {
self.body = Some(new_val);
}
pub fn thread(&self) -> usize {
self.thread
}
pub fn set_thread(&mut self, new_val: usize) -> () {
self.thread = new_val;
}
pub fn set_datetime(&mut self, new_val: chrono::DateTime<chrono::FixedOffset>) -> () {
self.datetime = Some(new_val);
self.timestamp = new_val.timestamp();
}
pub fn flags(&self) -> Flag {
self.flags
}
pub fn is_seen(&self) -> bool {
!(self.flags & Flag::SEEN).is_empty()
}
}
impl Eq for Envelope {} impl Eq for Envelope {}
impl Ord for Envelope { impl Ord for Envelope {
fn cmp(&self, other: &Envelope) -> Ordering { fn cmp(&self, other: &Envelope) -> Ordering {
self.get_datetime().cmp(&other.get_datetime()) self.datetime().cmp(&other.datetime())
} }
} }
impl PartialOrd for Envelope { impl PartialOrd for Envelope {
@ -458,6 +458,6 @@ impl PartialOrd for Envelope {
impl PartialEq for Envelope { impl PartialEq for Envelope {
fn eq(&self, other: &Envelope) -> bool { fn eq(&self, other: &Envelope) -> bool {
self.get_message_id_raw() == other.get_message_id_raw() self.message_id_raw() == other.message_id_raw()
} }
} }

4
melib/src/mailbox/email/parser.rs
View File

@ -178,7 +178,7 @@ fn encoded_word(input: &[u8]) -> IResult<&[u8], Vec<u8>> {
Ok(v) => v, Ok(v) => v,
Err(_) => encoded.to_vec(), Err(_) => encoded.to_vec(),
}, },
b'q' | b'Q' => match get_quoted_printed_bytes(encoded) { b'q' | b'Q' => match quoted_printed_bytes(encoded) {
IResult::Done(b"", s) => s, IResult::Done(b"", s) => s,
_ => return IResult::Error(error_code!(ErrorKind::Custom(43))), _ => return IResult::Error(error_code!(ErrorKind::Custom(43))),
}, },
@ -239,7 +239,7 @@ fn encoded_word(input: &[u8]) -> IResult<&[u8], Vec<u8>> {
named!(qp_underscore_header<u8>, do_parse!(tag!("_") >> ({ b' ' }))); named!(qp_underscore_header<u8>, do_parse!(tag!("_") >> ({ b' ' })));
named!( named!(
get_quoted_printed_bytes<Vec<u8>>, quoted_printed_bytes<Vec<u8>>,
many0!(alt_complete!( many0!(alt_complete!(
quoted_printable_byte | qp_underscore_header | le_u8 quoted_printable_byte | qp_underscore_header | le_u8
)) ))

12
melib/src/mailbox/mod.rs
View File

@ -56,7 +56,7 @@ impl Mailbox {
} }
pub fn new(folder: &Folder, sent_folder: &Option<Result<Mailbox>>, collection: Result<Vec<Envelope>>) -> Result<Mailbox> { pub fn new(folder: &Folder, sent_folder: &Option<Result<Mailbox>>, collection: Result<Vec<Envelope>>) -> Result<Mailbox> {
let mut collection: Vec<Envelope> = collection?; let mut collection: Vec<Envelope> = collection?;
collection.sort_by(|a, b| a.get_date().cmp(&b.get_date())); collection.sort_by(|a, b| a.date().cmp(&b.date()));
let (threads, threaded_collection) = build_threads(&mut collection, sent_folder); let (threads, threaded_collection) = build_threads(&mut collection, sent_folder);
Ok(Mailbox { Ok(Mailbox {
folder: folder.clone(), folder: folder.clone(),
@ -68,16 +68,16 @@ impl Mailbox {
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.collection.len() self.collection.len()
} }
pub fn get_threaded_mail(&self, i: usize) -> usize { pub fn threaded_mail(&self, i: usize) -> usize {
let thread = self.threads[self.threaded_collection[i]]; let thread = self.threads[self.threaded_collection[i]];
thread.get_message().unwrap() thread.message().unwrap()
} }
pub fn get_mail_and_thread(&mut self, i: usize) -> (&mut Envelope, Container) { pub fn mail_and_thread(&mut self, i: usize) -> (&mut Envelope, Container) {
let x = &mut self.collection.as_mut_slice()[i]; let x = &mut self.collection.as_mut_slice()[i];
let thread = self.threads[x.get_thread()]; let thread = self.threads[x.thread()];
(x, thread) (x, thread)
} }
pub fn get_thread(&self, i: usize) -> &Container { pub fn thread(&self, i: usize) -> &Container {
&self.threads[i] &self.threads[i]
} }
} }

72
melib/src/mailbox/thread.rs
View File

@ -51,19 +51,19 @@ pub struct Container {
} }
impl Container { impl Container {
pub fn get_message(&self) -> Option<usize> { pub fn message(&self) -> Option<usize> {
self.message self.message
} }
pub fn get_parent(&self) -> Option<usize> { pub fn parent(&self) -> Option<usize> {
self.parent self.parent
} }
pub fn has_parent(&self) -> bool { pub fn has_parent(&self) -> bool {
self.parent.is_some() self.parent.is_some()
} }
pub fn get_first_child(&self) -> Option<usize> { pub fn first_child(&self) -> Option<usize> {
self.first_child self.first_child
} }
pub fn get_next_sibling(&self) -> Option<usize> { pub fn next_sibling(&self) -> Option<usize> {
self.next_sibling self.next_sibling
} }
pub fn has_children(&self) -> bool { pub fn has_children(&self) -> bool {
@ -78,7 +78,7 @@ impl Container {
fn set_indentation(&mut self, i: usize) { fn set_indentation(&mut self, i: usize) {
self.indentation = i; self.indentation = i;
} }
pub fn get_indentation(&self) -> usize { pub fn indentation(&self) -> usize {
self.indentation self.indentation
} }
fn is_descendant(&self, threads: &[Container], other: &Container) -> bool { fn is_descendant(&self, threads: &[Container], other: &Container) -> bool {
@ -101,7 +101,7 @@ impl Container {
fn set_show_subject(&mut self, set: bool) -> () { fn set_show_subject(&mut self, set: bool) -> () {
self.show_subject = set; self.show_subject = set;
} }
pub fn get_show_subject(&self) -> bool { pub fn show_subject(&self) -> bool {
self.show_subject self.show_subject
} }
} }
@ -122,7 +122,7 @@ fn build_collection(
) -> () { ) -> () {
for (i, x) in collection.iter_mut().enumerate() { for (i, x) in collection.iter_mut().enumerate() {
let x_index; /* x's index in threads */ let x_index; /* x's index in threads */
let m_id = x.get_message_id_raw().to_string(); let m_id = x.message_id_raw().to_string();
/* TODO: Check for missing Message-ID. /* TODO: Check for missing Message-ID.
* Solutions: generate a hidden one * Solutions: generate a hidden one
*/ */
@ -136,7 +136,7 @@ fn build_collection(
} }
x_index = t; x_index = t;
/* Store this message in the Container's message slot. */ /* Store this message in the Container's message slot. */
threads[t].date = x.get_date(); threads[t].date = x.date();
x.set_thread(t); x.set_thread(t);
threads[t].message = Some(i); threads[t].message = Some(i);
} else { } else {
@ -148,7 +148,7 @@ fn build_collection(
parent: None, parent: None,
first_child: None, first_child: None,
next_sibling: None, next_sibling: None,
date: x.get_date(), date: x.date(),
indentation: 0, indentation: 0,
show_subject: true, show_subject: true,
}); });
@ -167,13 +167,13 @@ fn build_collection(
*/ */
let mut curr_ref = x_index; let mut curr_ref = x_index;
let mut iasf = 0; let mut iasf = 0;
for &r in x.get_references().iter().rev() { for &r in x.references().iter().rev() {
if iasf == 1 { if iasf == 1 {
continue; continue;
} }
iasf += 1; iasf += 1;
let parent_id = if id_table.contains_key(r.get_raw()) { let parent_id = if id_table.contains_key(r.raw()) {
let p = id_table[r.get_raw()]; let p = id_table[r.raw()];
if !(threads[p].is_descendant(threads, &threads[curr_ref]) || if !(threads[p].is_descendant(threads, &threads[curr_ref]) ||
threads[curr_ref].is_descendant(threads, &threads[p])) threads[curr_ref].is_descendant(threads, &threads[p]))
{ {
@ -199,22 +199,22 @@ fn build_collection(
parent: None, parent: None,
first_child: Some(curr_ref), first_child: Some(curr_ref),
next_sibling: None, next_sibling: None,
date: x.get_date(), date: x.date(),
indentation: 0, indentation: 0,
show_subject: true, show_subject: true,
}); });
if threads[curr_ref].parent.is_none() { if threads[curr_ref].parent.is_none() {
threads[curr_ref].parent = Some(idx); threads[curr_ref].parent = Some(idx);
} }
id_table.insert(r.get_raw().to_string(), idx); id_table.insert(r.raw().to_string(), idx);
idx idx
}; };
/* update thread date */ /* update thread date */
let mut parent_iter = parent_id; let mut parent_iter = parent_id;
'date: loop { 'date: loop {
let p = &mut threads[parent_iter]; let p = &mut threads[parent_iter];
if p.date < x.get_date() { if p.date < x.date() {
p.date = x.get_date(); p.date = x.date();
} }
match p.parent { match p.parent {
Some(p) => { Some(p) => {
@ -264,27 +264,27 @@ pub fn build_threads(
let sent_mailbox = sent_mailbox.unwrap(); let sent_mailbox = sent_mailbox.unwrap();
for x in &sent_mailbox.collection { for x in &sent_mailbox.collection {
if id_table.contains_key(x.get_message_id_raw()) || if id_table.contains_key(x.message_id_raw()) ||
(!x.get_in_reply_to_raw().is_empty() && (!x.in_reply_to_raw().is_empty() &&
id_table.contains_key(x.get_in_reply_to_raw())) id_table.contains_key(x.in_reply_to_raw()))
{ {
let mut x: Envelope = (*x).clone(); let mut x: Envelope = (*x).clone();
if id_table.contains_key(x.get_message_id_raw()) { if id_table.contains_key(x.message_id_raw()) {
let c = id_table[x.get_message_id_raw()]; let c = id_table[x.message_id_raw()];
if threads[c].message.is_some() { if threads[c].message.is_some() {
/* skip duplicate message-id, but this should be handled instead */ /* skip duplicate message-id, but this should be handled instead */
continue; continue;
} }
threads[c].message = Some(idx); threads[c].message = Some(idx);
assert!(threads[c].has_children()); assert!(threads[c].has_children());
threads[c].date = x.get_date(); threads[c].date = x.date();
x.set_thread(c); x.set_thread(c);
} else if !x.get_in_reply_to_raw().is_empty() && } else if !x.in_reply_to_raw().is_empty() &&
id_table.contains_key(x.get_in_reply_to_raw()) id_table.contains_key(x.in_reply_to_raw())
{ {
let p = id_table[x.get_in_reply_to_raw()]; let p = id_table[x.in_reply_to_raw()];
let c = if id_table.contains_key(x.get_message_id_raw()) { let c = if id_table.contains_key(x.message_id_raw()) {
id_table[x.get_message_id_raw()] id_table[x.message_id_raw()]
} else { } else {
threads.push(Container { threads.push(Container {
message: Some(idx), message: Some(idx),
@ -292,11 +292,11 @@ pub fn build_threads(
parent: Some(p), parent: Some(p),
first_child: None, first_child: None,
next_sibling: None, next_sibling: None,
date: x.get_date(), date: x.date(),
indentation: 0, indentation: 0,
show_subject: true, show_subject: true,
}); });
id_table.insert(x.get_message_id_raw().to_string(), tidx); id_table.insert(x.message_id_raw().to_string(), tidx);
x.set_thread(tidx); x.set_thread(tidx);
tidx += 1; tidx += 1;
tidx - 1 tidx - 1
@ -322,8 +322,8 @@ pub fn build_threads(
let mut parent_iter = p; let mut parent_iter = p;
'date: loop { 'date: loop {
let p = &mut threads[parent_iter]; let p = &mut threads[parent_iter];
if p.date < x.get_date() { if p.date < x.date() {
p.date = x.get_date(); p.date = x.date();
} }
match p.parent { match p.parent {
Some(p) => { Some(p) => {
@ -372,12 +372,12 @@ pub fn build_threads(
let thread = threads[i]; let thread = threads[i];
if threads[root_subject_idx].has_message() { if threads[root_subject_idx].has_message() {
let root_subject = let root_subject =
collection[threads[root_subject_idx].get_message().unwrap()].get_subject(); collection[threads[root_subject_idx].message().unwrap()].subject();
/* If the Container has no Message, but does have children, remove this container but /* If the Container has no Message, but does have children, remove this container but
* promote its children to this level (that is, splice them in to the current child * promote its children to this level (that is, splice them in to the current child
* list.) */ * list.) */
if indentation > 0 && thread.has_message() { if indentation > 0 && thread.has_message() {
let subject = collection[thread.get_message().unwrap()].get_subject(); let subject = collection[thread.message().unwrap()].subject();
if subject == root_subject || if subject == root_subject ||
subject.starts_with("Re: ") && subject.ends_with(root_subject) subject.starts_with("Re: ") && subject.ends_with(root_subject)
{ {
@ -385,7 +385,7 @@ pub fn build_threads(
} }
} }
} }
if thread.has_parent() && !threads[thread.get_parent().unwrap()].has_message() { if thread.has_parent() && !threads[thread.parent().unwrap()].has_message() {
threads[i].parent = None; threads[i].parent = None;
} }
let indentation = if thread.has_message() { let indentation = if thread.has_message() {
@ -400,14 +400,14 @@ pub fn build_threads(
indentation + 1 indentation + 1
}; };
if thread.has_children() { if thread.has_children() {
let mut fc = thread.get_first_child().unwrap(); let mut fc = thread.first_child().unwrap();
loop { loop {
build_threaded(threads, indentation, threaded, fc, i, collection); build_threaded(threads, indentation, threaded, fc, i, collection);
let thread_ = threads[fc]; let thread_ = threads[fc];
if !thread_.has_sibling() { if !thread_.has_sibling() {
break; break;
} }
fc = thread_.get_next_sibling().unwrap(); fc = thread_.next_sibling().unwrap();
} }
} }
} }

2
src/bin.rs
View File

@ -87,7 +87,7 @@ fn main() {
'inner: loop { 'inner: loop {
/* Check if any entities have sent reply events to State. */ /* Check if any entities have sent reply events to State. */
let events: Vec<UIEvent> = state.context.get_replies(); let events: Vec<UIEvent> = state.context.replies();
for e in events { for e in events {
state.rcv_event(e); state.rcv_event(e);
} }

4
ui/src/cells.rs
View File

@ -273,7 +273,7 @@ impl Cell {
/// let mut cell = Cell::with_style(Color::Blue, Color::Default, Attr::Default); /// let mut cell = Cell::with_style(Color::Blue, Color::Default, Attr::Default);
/// assert_eq!(cell.fg(), Color::Blue); /// assert_eq!(cell.fg(), Color::Blue);
/// ``` /// ```
pub fn get_fg(&self) -> Color { pub fn fg(&self) -> Color {
self.fg self.fg
} }
@ -305,7 +305,7 @@ impl Cell {
/// let mut cell = Cell::with_style(Color::Default, Color::Green, Attr::Default); /// let mut cell = Cell::with_style(Color::Default, Color::Green, Attr::Default);
/// assert_eq!(cell.bg(), Color::Green); /// assert_eq!(cell.bg(), Color::Green);
/// ``` /// ```
pub fn get_bg(&self) -> Color { pub fn bg(&self) -> Color {
self.bg self.bg
} }

42
ui/src/components/mail/listing.rs
View File

@ -22,7 +22,7 @@ impl MailListing {
/// Helper function to format entry strings for MailListing */ /// Helper function to format entry strings for MailListing */
/* TODO: Make this configurable */ /* TODO: Make this configurable */
fn make_entry_string(e: &Envelope, idx: usize) -> String { fn make_entry_string(e: &Envelope, idx: usize) -> String {
format!("{} {} {:.85}",idx,&e.get_datetime().format("%Y-%m-%d %H:%M:%S").to_string(),e.get_subject()) format!("{} {} {:.85}",idx,&e.datetime().format("%Y-%m-%d %H:%M:%S").to_string(),e.subject())
} }
pub fn new() -> Self { pub fn new() -> Self {
@ -61,7 +61,7 @@ impl MailListing {
let mut content = CellBuffer::new(MAX_COLS, self.length+1, Cell::with_char(' ')); let mut content = CellBuffer::new(MAX_COLS, self.length+1, Cell::with_char(' '));
if self.length == 0 { if self.length == 0 {
write_string_to_grid(&format!("Folder `{}` is empty.", write_string_to_grid(&format!("Folder `{}` is empty.",
mailbox.folder.get_name()), mailbox.folder.name()),
&mut content, &mut content,
Color::Default, Color::Default,
Color::Default, Color::Default,
@ -83,13 +83,13 @@ impl MailListing {
.peekable(); .peekable();
/* This is just a desugared for loop so that we can use .peek() */ /* This is just a desugared for loop so that we can use .peek() */
while let Some((idx, i)) = iter.next() { while let Some((idx, i)) = iter.next() {
let container = mailbox.get_thread(*i); let container = mailbox.thread(*i);
let indentation = container.get_indentation(); let indentation = container.indentation();
assert_eq!(container.has_message(), true); assert_eq!(container.has_message(), true);
match iter.peek() { match iter.peek() {
Some(&(_, x)) Some(&(_, x))
if mailbox.get_thread(*x).get_indentation() == indentation => if mailbox.thread(*x).indentation() == indentation =>
{ {
indentations.pop(); indentations.pop();
indentations.push(true); indentations.push(true);
@ -103,7 +103,7 @@ impl MailListing {
indentations.pop(); indentations.pop();
indentations.push(true); indentations.push(true);
} }
let envelope : &Envelope = &mailbox.collection[container.get_message().unwrap()]; let envelope : &Envelope = &mailbox.collection[container.message().unwrap()];
let fg_color = if !envelope.is_seen() { let fg_color = if !envelope.is_seen() {
Color::Byte(0) Color::Byte(0)
} else { } else {
@ -129,14 +129,14 @@ impl MailListing {
match iter.peek() { match iter.peek() {
Some(&(_, x)) Some(&(_, x))
if mailbox.get_thread(*x).get_indentation() > indentation => if mailbox.thread(*x).indentation() > indentation =>
{ {
indentations.push(false); indentations.push(false);
} }
Some(&(_, x)) Some(&(_, x))
if mailbox.get_thread(*x).get_indentation() < indentation => if mailbox.thread(*x).indentation() < indentation =>
{ {
for _ in 0..(indentation - mailbox.get_thread(*x).get_indentation()) { for _ in 0..(indentation - mailbox.thread(*x).indentation()) {
indentations.pop(); indentations.pop();
} }
} }
@ -193,7 +193,7 @@ impl MailListing {
let threaded = context.accounts[self.cursor_pos.0].settings.threaded; let threaded = context.accounts[self.cursor_pos.0].settings.threaded;
let mailbox = &context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap(); let mailbox = &context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap();
let envelope: &Envelope = if threaded { let envelope: &Envelope = if threaded {
let i = mailbox.get_threaded_mail(idx); let i = mailbox.threaded_mail(idx);
&mailbox.collection[i] &mailbox.collection[i]
} else { } else {
&mailbox.collection[idx] &mailbox.collection[idx]
@ -268,7 +268,7 @@ impl MailListing {
let threaded = context.accounts[self.cursor_pos.0].settings.threaded; let threaded = context.accounts[self.cursor_pos.0].settings.threaded;
let mailbox = &mut context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap(); let mailbox = &mut context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap();
let envelope: &Envelope = if threaded { let envelope: &Envelope = if threaded {
let i = mailbox.get_threaded_mail(self.cursor_pos.2); let i = mailbox.threaded_mail(self.cursor_pos.2);
&mailbox.collection[i] &mailbox.collection[i]
} else { } else {
&mailbox.collection[self.cursor_pos.2] &mailbox.collection[self.cursor_pos.2]
@ -283,9 +283,9 @@ impl MailListing {
container: &Container, indentations: &Vec<bool>) -> String { container: &Container, indentations: &Vec<bool>) -> String {
let has_sibling = container.has_sibling(); let has_sibling = container.has_sibling();
let has_parent = container.has_parent(); let has_parent = container.has_parent();
let show_subject = container.get_show_subject(); let show_subject = container.show_subject();
let mut s = format!("{} {} ", idx, &envelope.get_datetime().format("%Y-%m-%d %H:%M:%S").to_string()); let mut s = format!("{} {} ", idx, &envelope.datetime().format("%Y-%m-%d %H:%M:%S").to_string());
for i in 0..indent { for i in 0..indent {
if indentations.len() > i && indentations[i] if indentations.len() > i && indentations[i]
{ {
@ -307,10 +307,10 @@ impl MailListing {
} }
s.push('─'); s.push('>'); s.push('─'); s.push('>');
} }
s.push_str(&format!(" {}∞ ", envelope.get_body().count_attachments())); s.push_str(&format!(" {}∞ ", envelope.body().count_attachments()));
if show_subject { if show_subject {
s.push_str(&format!("{:.85}", envelope.get_subject())); s.push_str(&format!("{:.85}", envelope.subject()));
} }
s s
} }
@ -373,13 +373,13 @@ impl Component for MailListing {
let threaded = context.accounts[self.cursor_pos.0].settings.threaded; let threaded = context.accounts[self.cursor_pos.0].settings.threaded;
let mailbox = &mut context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap(); let mailbox = &mut context.accounts[self.cursor_pos.0][self.cursor_pos.1].as_ref().unwrap().as_ref().unwrap();
let envelope: &Envelope = if threaded { let envelope: &Envelope = if threaded {
let i = mailbox.get_threaded_mail(self.cursor_pos.2); let i = mailbox.threaded_mail(self.cursor_pos.2);
&mailbox.collection[i] &mailbox.collection[i]
} else { } else {
&mailbox.collection[self.cursor_pos.2] &mailbox.collection[self.cursor_pos.2]
}; };
let (x,y) = write_string_to_grid(&format!("Date: {}", envelope.get_date_as_str()), let (x,y) = write_string_to_grid(&format!("Date: {}", envelope.date_as_str()),
grid, grid,
Color::Byte(33), Color::Byte(33),
Color::Default, Color::Default,
@ -390,7 +390,7 @@ impl Component for MailListing {
grid[(x, y)].set_bg(Color::Default); grid[(x, y)].set_bg(Color::Default);
grid[(x, y)].set_fg(Color::Default); grid[(x, y)].set_fg(Color::Default);
} }
let (x,y) = write_string_to_grid(&format!("From: {}", envelope.get_from()), let (x,y) = write_string_to_grid(&format!("From: {}", envelope.from()),
grid, grid,
Color::Byte(33), Color::Byte(33),
Color::Default, Color::Default,
@ -401,7 +401,7 @@ impl Component for MailListing {
grid[(x, y)].set_bg(Color::Default); grid[(x, y)].set_bg(Color::Default);
grid[(x, y)].set_fg(Color::Default); grid[(x, y)].set_fg(Color::Default);
} }
let (x,y) = write_string_to_grid(&format!("To: {}", envelope.get_to()), let (x,y) = write_string_to_grid(&format!("To: {}", envelope.to()),
grid, grid,
Color::Byte(33), Color::Byte(33),
Color::Default, Color::Default,
@ -412,7 +412,7 @@ impl Component for MailListing {
grid[(x, y)].set_bg(Color::Default); grid[(x, y)].set_bg(Color::Default);
grid[(x, y)].set_fg(Color::Default); grid[(x, y)].set_fg(Color::Default);
} }
let (x,y) = write_string_to_grid(&format!("Subject: {}", envelope.get_subject()), let (x,y) = write_string_to_grid(&format!("Subject: {}", envelope.subject()),
grid, grid,
Color::Byte(33), Color::Byte(33),
Color::Default, Color::Default,
@ -423,7 +423,7 @@ impl Component for MailListing {
grid[(x, y)].set_bg(Color::Default); grid[(x, y)].set_bg(Color::Default);
grid[(x, y)].set_fg(Color::Default); grid[(x, y)].set_fg(Color::Default);
} }
let (x, y) = write_string_to_grid(&format!("Message-ID: {}", envelope.get_message_id_raw()), let (x, y) = write_string_to_grid(&format!("Message-ID: {}", envelope.message_id_raw()),
grid, grid,
Color::Byte(33), Color::Byte(33),
Color::Default, Color::Default,

10
ui/src/components/mail/mod.rs
View File

@ -25,7 +25,7 @@ impl AccountMenu {
pub fn new(accounts: &Vec<Account>) -> Self { pub fn new(accounts: &Vec<Account>) -> Self {
let accounts = accounts.iter().enumerate().map(|(i, a)| { let accounts = accounts.iter().enumerate().map(|(i, a)| {
AccountMenuEntry { AccountMenuEntry {
name: a.get_name().to_string(), name: a.name().to_string(),
index: i, index: i,
entries: { entries: {
let mut entries = Vec::with_capacity(a.len()); let mut entries = Vec::with_capacity(a.len());
@ -54,7 +54,7 @@ impl AccountMenu {
let mut parents: Vec<Option<usize>> = vec!(None; a.entries.len()); let mut parents: Vec<Option<usize>> = vec!(None; a.entries.len());
for (idx, e) in a.entries.iter().enumerate() { for (idx, e) in a.entries.iter().enumerate() {
for c in e.1.get_children() { for c in e.1.children() {
parents[*c] = Some(idx); parents[*c] = Some(idx);
} }
} }
@ -79,10 +79,10 @@ impl AccountMenu {
fn print(root: usize, parents: &Vec<Option<usize>>, depth: &mut String, entries: &Vec<(usize, Folder)>, s: &mut String, inc: &mut usize) -> () { fn print(root: usize, parents: &Vec<Option<usize>>, depth: &mut String, entries: &Vec<(usize, Folder)>, s: &mut String, inc: &mut usize) -> () {
let len = s.len(); let len = s.len();
s.insert_str(len, &format!("{} {}\n ", *inc, &entries[root].1.get_name())); s.insert_str(len, &format!("{} {}\n ", *inc, &entries[root].1.name()));
*inc += 1; *inc += 1;
let children_no = entries[root].1.get_children().len(); let children_no = entries[root].1.children().len();
for (idx, child) in entries[root].1.get_children().iter().enumerate() { for (idx, child) in entries[root].1.children().iter().enumerate() {
let len = s.len(); let len = s.len();
s.insert_str(len, &format!("{}├─", depth)); s.insert_str(len, &format!("{}├─", depth));
push(depth, if idx == children_no - 1 {'│'} else { ' ' }); push(depth, if idx == children_no - 1 {'│'} else { ' ' });

1
ui/src/components/notifications.rs
View File

@ -4,7 +4,6 @@
use notify_rust::Notification as notify_Notification; use notify_rust::Notification as notify_Notification;
use super::*; use super::*;
use super::components::*;
/// Passes notifications to the OS using the XDG specifications. /// Passes notifications to the OS using the XDG specifications.
pub struct XDGNotifications {} pub struct XDGNotifications {}

6
ui/src/components/utilities.rs
View File

@ -135,7 +135,7 @@ pub struct Pager {
// TODO: Make the `new` method content agnostic. // TODO: Make the `new` method content agnostic.
impl Pager { impl Pager {
pub fn new(mail: &Envelope, pager_filter: Option<String>) -> Self { pub fn new(mail: &Envelope, pager_filter: Option<String>) -> Self {
let mut text = mail.get_body().get_text(); let mut text = mail.body().text();
if let Some(bin) = pager_filter { if let Some(bin) = pager_filter {
use std::io::Write; use std::io::Write;
use std::process::{Command, Stdio}; use std::process::{Command, Stdio};
@ -219,7 +219,7 @@ impl Component for Pager {
//let pager_context: usize = context.settings.pager.pager_context; //let pager_context: usize = context.settings.pager.pager_context;
//let pager_stop: bool = context.settings.pager.pager_stop; //let pager_stop: bool = context.settings.pager.pager_stop;
//let rows = get_y(bottom_right) - get_y(upper_left); //let rows = y(bottom_right) - y(upper_left);
//let page_length = rows / self.height; //let page_length = rows / self.height;
copy_area(grid, &self.content, area, ((0, self.cursor_pos), (self.width - 1, self.height - 1))); copy_area(grid, &self.content, area, ((0, self.cursor_pos), (self.width - 1, self.height - 1)));
context.dirty_areas.push_back(area); context.dirty_areas.push_back(area);
@ -336,7 +336,7 @@ impl Component for StatusBar {
match event.event_type { match event.event_type {
UIEventType::RefreshMailbox((idx_a, idx_f)) => { UIEventType::RefreshMailbox((idx_a, idx_f)) => {
let m = &context.accounts[idx_a][idx_f].as_ref().unwrap().as_ref().unwrap(); let m = &context.accounts[idx_a][idx_f].as_ref().unwrap().as_ref().unwrap();
self.status = format!("{} |Mailbox: {}, Messages: {}, New: {}", self.mode, m.folder.get_name(), m.collection.len(), m.collection.iter().filter(|e| !e.is_seen()).count()); self.status = format!("{} |Mailbox: {}, Messages: {}, New: {}", self.mode, m.folder.name(), m.collection.len(), m.collection.iter().filter(|e| !e.is_seen()).count());
self.dirty = true; self.dirty = true;
}, },

18
ui/src/lib.rs
View File

@ -21,7 +21,7 @@
/*! /*!
The UI module has an Entity-Component-System design. The System part, is also the application's state, so they're both merged in the `State` struct. The UI crate has an Entity-Component-System design. The System part, is also the application's state, so they're both merged in the `State` struct.
`State` owns all the Entities of the UI, which are currently plain Containers for `Component`s. In the application's main event loop, input is handed to the state in the form of `UIEvent` objects which traverse the entity graph. Components decide to handle each input or not. `State` owns all the Entities of the UI, which are currently plain Containers for `Component`s. In the application's main event loop, input is handed to the state in the form of `UIEvent` objects which traverse the entity graph. Components decide to handle each input or not.
@ -133,7 +133,7 @@ pub struct Context {
} }
impl Context { impl Context {
pub fn get_replies(&mut self) -> Vec<UIEvent> { pub fn replies(&mut self) -> Vec<UIEvent> {
self.replies.drain(0..).collect() self.replies.drain(0..).collect()
} }
} }
@ -171,7 +171,7 @@ impl<W: Write> State<W> {
let cols = termcols.unwrap_or(0) as usize; let cols = termcols.unwrap_or(0) as usize;
let rows = termrows.unwrap_or(0) as usize; let rows = termrows.unwrap_or(0) as usize;
let mut accounts: Vec<Account> = settings.accounts.iter().map(|(n, a_s)| { Account::new(n.to_string(), a_s.clone(), &backends) }).collect(); let mut accounts: Vec<Account> = settings.accounts.iter().map(|(n, a_s)| { Account::new(n.to_string(), a_s.clone(), &backends) }).collect();
accounts.sort_by(|a,b| a.get_name().cmp(&b.get_name()) ); accounts.sort_by(|a,b| a.name().cmp(&b.name()) );
let mut s = State { let mut s = State {
cols: cols, cols: cols,
rows: rows, rows: rows,
@ -233,17 +233,17 @@ impl<W: Write> State<W> {
for x in get_x(upper_left)..=get_x(bottom_right) { for x in get_x(upper_left)..=get_x(bottom_right) {
let c = self.grid[(x,y)]; let c = self.grid[(x,y)];
if c.get_bg() != cells::Color::Default { if c.bg() != cells::Color::Default {
write!(self.stdout, "{}", termion::color::Bg(c.get_bg().as_termion())).unwrap(); write!(self.stdout, "{}", termion::color::Bg(c.bg().as_termion())).unwrap();
} }
if c.get_fg() != cells::Color::Default { if c.fg() != cells::Color::Default {
write!(self.stdout, "{}", termion::color::Fg(c.get_fg().as_termion())).unwrap(); write!(self.stdout, "{}", termion::color::Fg(c.fg().as_termion())).unwrap();
} }
write!(self.stdout, "{}",c.ch()).unwrap(); write!(self.stdout, "{}",c.ch()).unwrap();
if c.get_bg() != cells::Color::Default { if c.bg() != cells::Color::Default {
write!(self.stdout, "{}", termion::color::Bg(termion::color::Reset)).unwrap(); write!(self.stdout, "{}", termion::color::Bg(termion::color::Reset)).unwrap();
} }
if c.get_fg() != cells::Color::Default { if c.fg() != cells::Color::Default {
write!(self.stdout, "{}", termion::color::Fg(termion::color::Reset)).unwrap(); write!(self.stdout, "{}", termion::color::Fg(termion::color::Reset)).unwrap();
} }