Fix clippy lints
parent
bbedeed3e3
commit
a7e177586a
|
@ -943,7 +943,6 @@ dependencies = [
|
|||
"nix",
|
||||
"nom",
|
||||
"notify",
|
||||
"pin-utils",
|
||||
"reqwest",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
|
|
|
@ -84,7 +84,7 @@ fn main() -> Result<(), std::io::Error> {
|
|||
.unwrap();
|
||||
file.write_all(b"use crate::types::LineBreakClass;\n\n")
|
||||
.unwrap();
|
||||
file.write_all(b"const line_break_rules: &'static [(u32, u32, LineBreakClass)] = &[\n")
|
||||
file.write_all(b"const LINE_BREAK_RULES: &[(u32, u32, LineBreakClass)] = &[\n")
|
||||
.unwrap();
|
||||
for l in &line_break_table {
|
||||
file.write_all(format!(" (0x{:X}, 0x{:X}, {:?}),\n", l.0, l.1, l.2).as_bytes())
|
||||
|
|
|
@ -45,8 +45,8 @@ impl VCardVersion for VCardVersion3 {}
|
|||
|
||||
pub struct CardDeserializer;
|
||||
|
||||
static HEADER: &'static str = "BEGIN:VCARD\r\n"; //VERSION:4.0\r\n";
|
||||
static FOOTER: &'static str = "END:VCARD\r\n";
|
||||
static HEADER: &str = "BEGIN:VCARD\r\n"; //VERSION:4.0\r\n";
|
||||
static FOOTER: &str = "END:VCARD\r\n";
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct VCard<T: VCardVersion>(
|
||||
|
|
|
@ -206,21 +206,21 @@ where
|
|||
recv(rx) -> r => {
|
||||
match r {
|
||||
Ok(p @ AsyncStatus::Payload(_)) => {
|
||||
return Ok(p);
|
||||
Ok(p)
|
||||
},
|
||||
Ok(f @ AsyncStatus::Finished) => {
|
||||
self.active = false;
|
||||
return Ok(f);
|
||||
Ok(f)
|
||||
},
|
||||
Ok(a) => {
|
||||
return Ok(a);
|
||||
Ok(a)
|
||||
}
|
||||
Err(_) => {
|
||||
return Err(());
|
||||
Err(())
|
||||
},
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
/// Polls worker thread and returns result.
|
||||
pub fn poll(&mut self) -> Result<AsyncStatus<T>, ()> {
|
||||
|
@ -231,25 +231,25 @@ where
|
|||
let rx = &self.rx;
|
||||
select! {
|
||||
default => {
|
||||
return Ok(AsyncStatus::NoUpdate);
|
||||
Ok(AsyncStatus::NoUpdate)
|
||||
},
|
||||
recv(rx) -> r => {
|
||||
match r {
|
||||
Ok(p @ AsyncStatus::Payload(_)) => {
|
||||
return Ok(p);
|
||||
Ok(p)
|
||||
},
|
||||
Ok(f @ AsyncStatus::Finished) => {
|
||||
self.active = false;
|
||||
return Ok(f);
|
||||
Ok(f)
|
||||
},
|
||||
Ok(a) => {
|
||||
return Ok(a);
|
||||
Ok(a)
|
||||
}
|
||||
Err(_) => {
|
||||
return Err(());
|
||||
Err(())
|
||||
},
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -72,7 +72,6 @@ pub use futures::stream::Stream;
|
|||
use std::future::Future;
|
||||
pub use std::pin::Pin;
|
||||
|
||||
use std;
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[macro_export]
|
||||
|
@ -111,10 +110,10 @@ impl Default for Backends {
|
|||
}
|
||||
|
||||
#[cfg(feature = "notmuch_backend")]
|
||||
pub const NOTMUCH_ERROR_MSG: &'static str =
|
||||
pub const NOTMUCH_ERROR_MSG: &str =
|
||||
"libnotmuch5 was not found in your system. Make sure it is installed and in the library paths.\n";
|
||||
#[cfg(not(feature = "notmuch_backend"))]
|
||||
pub const NOTMUCH_ERROR_MSG: &'static str = "this version of meli is not compiled with notmuch support. Use an appropriate version and make sure libnotmuch5 is installed and in the library paths.\n";
|
||||
pub const NOTMUCH_ERROR_MSG: &str = "this version of meli is not compiled with notmuch support. Use an appropriate version and make sure libnotmuch5 is installed and in the library paths.\n";
|
||||
|
||||
impl Backends {
|
||||
pub fn new() -> Self {
|
||||
|
@ -306,7 +305,7 @@ pub trait MailBackend: ::std::fmt::Debug + Send + Sync {
|
|||
fn get(&mut self, mailbox: &Mailbox) -> Async<Result<Vec<Envelope>>>;
|
||||
fn get_async(
|
||||
&mut self,
|
||||
mailbox: &Mailbox,
|
||||
_mailbox: &Mailbox,
|
||||
) -> Result<Pin<Box<dyn Stream<Item = Result<Vec<Envelope>>> + Send + 'static>>> {
|
||||
Err(MeliError::new("Unimplemented."))
|
||||
}
|
||||
|
@ -329,7 +328,7 @@ pub trait MailBackend: ::std::fmt::Debug + Send + Sync {
|
|||
sender: RefreshEventConsumer,
|
||||
work_context: WorkContext,
|
||||
) -> Result<std::thread::ThreadId>;
|
||||
fn watch_async(&self, sender: RefreshEventConsumer) -> ResultFuture<()> {
|
||||
fn watch_async(&self, _sender: RefreshEventConsumer) -> ResultFuture<()> {
|
||||
Err(MeliError::new("Unimplemented."))
|
||||
}
|
||||
fn mailboxes(&self) -> Result<HashMap<MailboxHash, Mailbox>>;
|
||||
|
@ -524,9 +523,7 @@ impl SpecialUsageMailbox {
|
|||
Some(SpecialUsageMailbox::Archive)
|
||||
} else if name.eq_ignore_ascii_case("drafts") {
|
||||
Some(SpecialUsageMailbox::Drafts)
|
||||
} else if name.eq_ignore_ascii_case("junk") {
|
||||
Some(SpecialUsageMailbox::Junk)
|
||||
} else if name.eq_ignore_ascii_case("spam") {
|
||||
} else if name.eq_ignore_ascii_case("junk") || name.eq_ignore_ascii_case("spam") {
|
||||
Some(SpecialUsageMailbox::Junk)
|
||||
} else if name.eq_ignore_ascii_case("sent") {
|
||||
Some(SpecialUsageMailbox::Sent)
|
||||
|
|
|
@ -52,7 +52,7 @@ use std::sync::{Arc, Mutex, RwLock};
|
|||
use std::time::Instant;
|
||||
pub type UID = usize;
|
||||
|
||||
pub static SUPPORTED_CAPABILITIES: &'static [&'static str] =
|
||||
pub static SUPPORTED_CAPABILITIES: &[&str] =
|
||||
&["IDLE", "LOGIN", "LOGINDISABLED", "ENABLE", "IMAP4REV1"];
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
|
@ -412,7 +412,7 @@ impl MailBackend for ImapType {
|
|||
debug!(
|
||||
"fetch response is {} bytes and {} lines",
|
||||
response.len(),
|
||||
response.lines().collect::<Vec<&str>>().len()
|
||||
response.lines().count()
|
||||
);
|
||||
let (_, v, _) = protocol_parser::uid_fetch_responses(&response)?;
|
||||
debug!("responses len is {}", v.len());
|
||||
|
@ -552,7 +552,7 @@ impl MailBackend for ImapType {
|
|||
.send(RefreshEvent {
|
||||
account_hash: uid_store.account_hash,
|
||||
mailbox_hash,
|
||||
kind: RefreshEventKind::Failure(err.clone()),
|
||||
kind: RefreshEventKind::Failure(err),
|
||||
});
|
||||
|
||||
return;
|
||||
|
@ -655,9 +655,6 @@ impl MailBackend for ImapType {
|
|||
};
|
||||
Ok(Box::new(ImapOp::new(
|
||||
uid,
|
||||
self.uid_store.mailboxes.read().unwrap()[&mailbox_hash]
|
||||
.imap_path()
|
||||
.to_string(),
|
||||
mailbox_hash,
|
||||
self.connection.clone(),
|
||||
self.uid_store.clone(),
|
||||
|
@ -673,10 +670,9 @@ impl MailBackend for ImapType {
|
|||
let path = {
|
||||
let mailboxes = self.uid_store.mailboxes.read().unwrap();
|
||||
|
||||
let mailbox = mailboxes.get(&mailbox_hash).ok_or(MeliError::new(format!(
|
||||
"Mailbox with hash {} not found.",
|
||||
mailbox_hash
|
||||
)))?;
|
||||
let mailbox = mailboxes.get(&mailbox_hash).ok_or_else(|| {
|
||||
MeliError::new(format!("Mailbox with hash {} not found.", mailbox_hash))
|
||||
})?;
|
||||
if !mailbox.permissions.lock().unwrap().create_messages {
|
||||
return Err(MeliError::new(format!(
|
||||
"You are not allowed to create messages in mailbox {}",
|
||||
|
@ -688,7 +684,7 @@ impl MailBackend for ImapType {
|
|||
};
|
||||
let mut response = String::with_capacity(8 * 1024);
|
||||
let mut conn = try_lock(&self.connection, Some(std::time::Duration::new(5, 0)))?;
|
||||
let flags = flags.unwrap_or(Flag::empty());
|
||||
let flags = flags.unwrap_or_else(Flag::empty);
|
||||
conn.send_command(
|
||||
format!(
|
||||
"APPEND \"{}\" ({}) {{{}}}",
|
||||
|
|
|
@ -35,8 +35,8 @@ pub use sqlite3_m::*;
|
|||
mod sqlite3_m {
|
||||
use super::*;
|
||||
use crate::sqlite3;
|
||||
const DB_NAME: &'static str = "header_cache.db";
|
||||
const INIT_SCRIPT: &'static str = "PRAGMA foreign_keys = true;
|
||||
const DB_NAME: &str = "header_cache.db";
|
||||
const INIT_SCRIPT: &str = "PRAGMA foreign_keys = true;
|
||||
PRAGMA encoding = 'UTF-8';
|
||||
|
||||
CREATE TABLE IF NOT EXISTS envelopes (
|
||||
|
|
|
@ -274,7 +274,9 @@ impl ImapStream {
|
|||
}
|
||||
}
|
||||
|
||||
if capabilities.is_none() {
|
||||
if let Some(capabilities) = capabilities {
|
||||
Ok((capabilities, ret))
|
||||
} else {
|
||||
/* sending CAPABILITY after LOGIN automatically is an RFC recommendation, so check
|
||||
* for lazy servers */
|
||||
drop(capabilities);
|
||||
|
@ -283,9 +285,6 @@ impl ImapStream {
|
|||
let capabilities = protocol_parser::capabilities(res.as_bytes())?.1;
|
||||
let capabilities = HashSet::from_iter(capabilities.into_iter().map(|s| s.to_vec()));
|
||||
Ok((capabilities, ret))
|
||||
} else {
|
||||
let capabilities = capabilities.unwrap();
|
||||
Ok((capabilities, ret))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -523,7 +522,7 @@ impl ImapConnection {
|
|||
}
|
||||
}
|
||||
if let Ok(ref mut stream) = self.stream {
|
||||
if let Ok(_) = action(stream) {
|
||||
if action(stream).is_ok() {
|
||||
self.uid_store.is_online.lock().unwrap().0 = Instant::now();
|
||||
return Ok(());
|
||||
}
|
||||
|
|
|
@ -37,7 +37,6 @@ pub struct ImapOp {
|
|||
impl ImapOp {
|
||||
pub fn new(
|
||||
uid: usize,
|
||||
mailbox_path: String,
|
||||
mailbox_hash: MailboxHash,
|
||||
connection: Arc<Mutex<ImapConnection>>,
|
||||
uid_store: Arc<UIDStore>,
|
||||
|
@ -66,7 +65,7 @@ impl BackendOp for ImapOp {
|
|||
debug!(
|
||||
"fetch response is {} bytes and {} lines",
|
||||
response.len(),
|
||||
response.lines().collect::<Vec<&str>>().len()
|
||||
response.lines().count()
|
||||
);
|
||||
let UidFetchResponse {
|
||||
uid, flags, body, ..
|
||||
|
@ -105,7 +104,7 @@ impl BackendOp for ImapOp {
|
|||
debug!(
|
||||
"fetch response is {} bytes and {} lines",
|
||||
response.len(),
|
||||
response.lines().collect::<Vec<&str>>().len()
|
||||
response.lines().count()
|
||||
);
|
||||
let v = protocol_parser::uid_fetch_flags_response(response.as_bytes())
|
||||
.map(|(_, v)| v)
|
||||
|
@ -131,8 +130,7 @@ impl BackendOp for ImapOp {
|
|||
let val = {
|
||||
let mut bytes_cache = uid_store.byte_cache.lock()?;
|
||||
let cache = bytes_cache.entry(uid).or_default();
|
||||
let val = cache.flags;
|
||||
val
|
||||
cache.flags
|
||||
};
|
||||
Ok(val.unwrap())
|
||||
}
|
||||
|
@ -174,11 +172,13 @@ impl BackendOp for ImapOp {
|
|||
Ok(v) => {
|
||||
if v.len() == 1 {
|
||||
debug!("responses len is {}", v.len());
|
||||
let (uid, (flags, _)) = v[0];
|
||||
let (uid, (_flags, _)) = v[0];
|
||||
assert_eq!(uid, uid);
|
||||
}
|
||||
}
|
||||
Err(e) => Err(e)?,
|
||||
Err(e) => {
|
||||
return Err(e);
|
||||
}
|
||||
}
|
||||
let mut bytes_cache = uid_store.byte_cache.lock()?;
|
||||
let cache = bytes_cache.entry(uid).or_default();
|
||||
|
|
|
@ -190,7 +190,7 @@ ReadWrite => write!(fmt, "This mailbox is selected with read-write permissions."
|
|||
impl ResponseCode {
|
||||
fn from(val: &str) -> ResponseCode {
|
||||
use ResponseCode::*;
|
||||
if !val.starts_with("[") {
|
||||
if !val.starts_with('[') {
|
||||
let msg = val.trim();
|
||||
return Alert(msg.to_string());
|
||||
}
|
||||
|
@ -235,7 +235,8 @@ pub enum ImapResponse {
|
|||
|
||||
impl<T: AsRef<str>> From<T> for ImapResponse {
|
||||
fn from(val: T) -> ImapResponse {
|
||||
let val: &str = val.as_ref().split_rn().last().unwrap_or(val.as_ref());
|
||||
let val_ref = val.as_ref();
|
||||
let val: &str = val_ref.split_rn().last().unwrap_or(val_ref);
|
||||
debug!(&val);
|
||||
let mut val = val[val.as_bytes().find(b" ").unwrap() + 1..].trim();
|
||||
// M12 NO [CANNOT] Invalid mailbox name: Name must not have \'/\' characters (0.000 + 0.098 + 0.097 secs).\r\n
|
||||
|
@ -616,7 +617,7 @@ pub fn uid_fetch_responses(mut input: &str) -> ImapParseResult<Vec<UidFetchRespo
|
|||
if let Some(el_alert) = el_alert {
|
||||
match &mut alert {
|
||||
Some(Alert(ref mut alert)) => {
|
||||
alert.extend(el_alert.0.chars());
|
||||
alert.push_str(&el_alert.0);
|
||||
}
|
||||
a @ None => *a = Some(el_alert),
|
||||
}
|
||||
|
@ -994,13 +995,13 @@ pub fn flags(input: &str) -> IResult<&str, (Flag, Vec<String>)> {
|
|||
let mut keywords = Vec::new();
|
||||
|
||||
let mut input = input;
|
||||
while !input.starts_with(")") && !input.is_empty() {
|
||||
if input.starts_with("\\") {
|
||||
while !input.starts_with(')') && !input.is_empty() {
|
||||
if input.starts_with('\\') {
|
||||
input = &input[1..];
|
||||
}
|
||||
let mut match_end = 0;
|
||||
while match_end < input.len() {
|
||||
if input[match_end..].starts_with(" ") || input[match_end..].starts_with(")") {
|
||||
if input[match_end..].starts_with(' ') || input[match_end..].starts_with(')') {
|
||||
break;
|
||||
}
|
||||
match_end += 1;
|
||||
|
@ -1337,13 +1338,13 @@ pub fn quoted(input: &[u8]) -> IResult<&[u8], Vec<u8>> {
|
|||
i += 1;
|
||||
}
|
||||
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "quoted(): not a quoted phrase").into(),
|
||||
));
|
||||
))
|
||||
}
|
||||
|
||||
pub fn quoted_or_nil(input: &[u8]) -> IResult<&[u8], Option<Vec<u8>>> {
|
||||
alt((map(tag("NIL"), |_| None), map(quoted, |v| Some(v))))(input.ltrim())
|
||||
alt((map(tag("NIL"), |_| None), map(quoted, Some)))(input.ltrim())
|
||||
/*
|
||||
alt_complete!(map!(ws!(tag!("NIL")), |_| None) | map!(quoted, |v| Some(v))));
|
||||
*/
|
||||
|
@ -1508,9 +1509,9 @@ fn string_token(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
|||
i += 1;
|
||||
}
|
||||
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "string_token(): not a quoted phrase").into(),
|
||||
));
|
||||
))
|
||||
}
|
||||
|
||||
// ASTRING-CHAR = ATOM-CHAR / resp-specials
|
||||
|
|
|
@ -56,7 +56,7 @@ use std::sync::{Arc, Mutex, RwLock};
|
|||
use std::time::Instant;
|
||||
pub type UID = usize;
|
||||
|
||||
pub static SUPPORTED_CAPABILITIES: &'static [&'static str] =
|
||||
pub static SUPPORTED_CAPABILITIES: &[&str] =
|
||||
&["IDLE", "LOGIN", "LOGINDISABLED", "ENABLE", "IMAP4REV1"];
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
|
@ -387,10 +387,9 @@ impl MailBackend for ImapType {
|
|||
let path = {
|
||||
let mailboxes = uid_store.mailboxes.lock().await;
|
||||
|
||||
let mailbox = mailboxes.get(&mailbox_hash).ok_or(MeliError::new(format!(
|
||||
"Mailbox with hash {} not found.",
|
||||
mailbox_hash
|
||||
)))?;
|
||||
let mailbox = mailboxes.get(&mailbox_hash).ok_or_else(|| {
|
||||
MeliError::new(format!("Mailbox with hash {} not found.", mailbox_hash))
|
||||
})?;
|
||||
if !mailbox.permissions.lock().unwrap().create_messages {
|
||||
return Err(MeliError::new(format!(
|
||||
"You are not allowed to create messages in mailbox {}",
|
||||
|
@ -402,7 +401,7 @@ impl MailBackend for ImapType {
|
|||
};
|
||||
let mut response = String::with_capacity(8 * 1024);
|
||||
let mut conn = connection.lock().await;
|
||||
let flags = flags.unwrap_or(Flag::empty());
|
||||
let flags = flags.unwrap_or_else(Flag::empty);
|
||||
conn.send_command(
|
||||
format!(
|
||||
"APPEND \"{}\" ({}) {{{}}}",
|
||||
|
@ -658,10 +657,10 @@ impl MailBackend for ImapType {
|
|||
fn set_mailbox_permissions(
|
||||
&mut self,
|
||||
mailbox_hash: MailboxHash,
|
||||
val: crate::backends::MailboxPermissions,
|
||||
_val: crate::backends::MailboxPermissions,
|
||||
) -> ResultFuture<()> {
|
||||
let uid_store = self.uid_store.clone();
|
||||
let connection = self.connection.clone();
|
||||
//let connection = self.connection.clone();
|
||||
Ok(Box::pin(async move {
|
||||
let mailboxes = uid_store.mailboxes.lock().await;
|
||||
let permissions = mailboxes[&mailbox_hash].permissions();
|
||||
|
@ -746,7 +745,7 @@ impl MailBackend for ImapType {
|
|||
}
|
||||
keyword => {
|
||||
s.push_str(" KEYWORD ");
|
||||
s.extend(keyword.chars());
|
||||
s.push_str(keyword);
|
||||
s.push_str(" ");
|
||||
}
|
||||
}
|
||||
|
@ -798,7 +797,7 @@ impl MailBackend for ImapType {
|
|||
.map(usize::from_str)
|
||||
.filter_map(std::result::Result::ok)
|
||||
.filter_map(|uid| uid_index.get(&(mailbox_hash, uid)))
|
||||
.map(|env_hash_ref| *env_hash_ref),
|
||||
.copied(),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
@ -1210,7 +1209,7 @@ async fn get_hlpr(
|
|||
debug!(
|
||||
"fetch response is {} bytes and {} lines",
|
||||
response.len(),
|
||||
response.lines().collect::<Vec<&str>>().len()
|
||||
response.lines().count()
|
||||
);
|
||||
let (_, v, _) = protocol_parser::uid_fetch_responses(&response)?;
|
||||
debug!("responses len is {}", v.len());
|
||||
|
|
|
@ -35,8 +35,8 @@ pub use sqlite3_m::*;
|
|||
mod sqlite3_m {
|
||||
use super::*;
|
||||
use crate::sqlite3;
|
||||
const DB_NAME: &'static str = "header_cache.db";
|
||||
const INIT_SCRIPT: &'static str = "PRAGMA foreign_keys = true;
|
||||
const DB_NAME: &str = "header_cache.db";
|
||||
const INIT_SCRIPT: &str = "PRAGMA foreign_keys = true;
|
||||
PRAGMA encoding = 'UTF-8';
|
||||
|
||||
CREATE TABLE IF NOT EXISTS envelopes (
|
||||
|
|
|
@ -422,11 +422,6 @@ impl ImapStream {
|
|||
self.stream.write_all(b"\r\n").await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn set_nonblocking(&mut self, val: bool) -> Result<()> {
|
||||
//self.stream.set_nonblocking(val).await?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ImapConnection {
|
||||
|
@ -552,11 +547,6 @@ impl ImapConnection {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn set_nonblocking(&mut self, val: bool) -> Result<()> {
|
||||
self.stream.as_mut()?.set_nonblocking(val).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn select_mailbox(
|
||||
&mut self,
|
||||
mailbox_hash: MailboxHash,
|
||||
|
@ -699,7 +689,7 @@ impl ImapBlockingConnection {
|
|||
self.err.as_ref().map(String::as_str)
|
||||
}
|
||||
|
||||
pub fn into_stream<'a>(&'a mut self) -> impl Future<Output = Option<Vec<u8>>> + 'a {
|
||||
pub fn as_stream<'a>(&'a mut self) -> impl Future<Output = Option<Vec<u8>>> + 'a {
|
||||
self.result.drain(0..self.prev_res_length);
|
||||
self.prev_res_length = 0;
|
||||
let mut break_flag = false;
|
||||
|
|
|
@ -53,7 +53,6 @@ impl ImapOp {
|
|||
|
||||
impl BackendOp for ImapOp {
|
||||
fn as_bytes(&mut self) -> ResultFuture<Vec<u8>> {
|
||||
let mut response = String::with_capacity(8 * 1024);
|
||||
let connection = self.connection.clone();
|
||||
let mailbox_hash = self.mailbox_hash;
|
||||
let uid = self.uid;
|
||||
|
@ -154,8 +153,7 @@ impl BackendOp for ImapOp {
|
|||
let val = {
|
||||
let mut bytes_cache = uid_store.byte_cache.lock()?;
|
||||
let cache = bytes_cache.entry(uid).or_default();
|
||||
let val = cache.flags;
|
||||
val
|
||||
cache.flags
|
||||
};
|
||||
Ok(val.unwrap())
|
||||
}
|
||||
|
@ -200,7 +198,7 @@ impl BackendOp for ImapOp {
|
|||
Ok(v) => {
|
||||
if v.len() == 1 {
|
||||
debug!("responses len is {}", v.len());
|
||||
let (_uid, (flags, _)) = v[0];
|
||||
let (_uid, (_flags, _)) = v[0];
|
||||
assert_eq!(_uid, uid);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1358,9 +1358,9 @@ pub fn quoted(input: &[u8]) -> IResult<&[u8], Vec<u8>> {
|
|||
i += 1;
|
||||
}
|
||||
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "quoted(): not a quoted phrase").into(),
|
||||
));
|
||||
))
|
||||
}
|
||||
|
||||
pub fn quoted_or_nil(input: &[u8]) -> IResult<&[u8], Option<Vec<u8>>> {
|
||||
|
@ -1529,9 +1529,9 @@ fn string_token(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
|||
i += 1;
|
||||
}
|
||||
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "string_token(): not a quoted phrase").into(),
|
||||
));
|
||||
))
|
||||
}
|
||||
|
||||
// ASTRING-CHAR = ATOM-CHAR / resp-specials
|
||||
|
|
|
@ -304,7 +304,7 @@ impl ImapConnection {
|
|||
Ok(mut v) => {
|
||||
if let Some(uid) = v.pop() {
|
||||
let lck = self.uid_store.uid_index.lock().unwrap();
|
||||
let env_hash = lck.get(&(mailbox_hash, uid)).map(|&h| h);
|
||||
let env_hash = lck.get(&(mailbox_hash, uid)).copied();
|
||||
drop(lck);
|
||||
if let Some(env_hash) = env_hash {
|
||||
if !flags.0.intersects(crate::email::Flag::SEEN) {
|
||||
|
|
|
@ -170,7 +170,7 @@ pub async fn idle(kit: ImapWatchKit) -> Result<()> {
|
|||
const _26_MINS: std::time::Duration = std::time::Duration::from_secs(26 * 60);
|
||||
/* duration interval to check other mailboxes for changes */
|
||||
const _5_MINS: std::time::Duration = std::time::Duration::from_secs(5 * 60);
|
||||
while let Some(line) = blockn.into_stream().await {
|
||||
while let Some(line) = blockn.as_stream().await {
|
||||
let now = std::time::Instant::now();
|
||||
if now.duration_since(beat) >= _26_MINS {
|
||||
let mut main_conn_lck = main_conn.lock().await;
|
||||
|
@ -203,7 +203,7 @@ pub async fn idle(kit: ImapWatchKit) -> Result<()> {
|
|||
.map(|(_, v)| v)
|
||||
.map_err(MeliError::from)
|
||||
{
|
||||
Ok(Some(Recent(r))) => {
|
||||
Ok(Some(Recent(_r))) => {
|
||||
let mut conn = main_conn.lock().await;
|
||||
/* UID SEARCH RECENT */
|
||||
exit_on_error!(
|
||||
|
|
|
@ -195,12 +195,11 @@ impl MailBackend for JmapType {
|
|||
}
|
||||
|
||||
fn connect(&mut self) {
|
||||
if self.is_online().is_err() {
|
||||
if Instant::now().duration_since(self.online.lock().unwrap().0)
|
||||
if self.is_online().is_err()
|
||||
&& Instant::now().duration_since(self.online.lock().unwrap().0)
|
||||
>= std::time::Duration::new(2, 0)
|
||||
{
|
||||
let _ = self.mailboxes();
|
||||
}
|
||||
{
|
||||
let _ = self.mailboxes();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -58,7 +58,7 @@ impl JmapConnection {
|
|||
};
|
||||
if server_conf.server_port != 443 {
|
||||
jmap_session_resource_url.push(':');
|
||||
jmap_session_resource_url.extend(server_conf.server_port.to_string().chars());
|
||||
jmap_session_resource_url.push_str(&server_conf.server_port.to_string());
|
||||
}
|
||||
jmap_session_resource_url.push_str("/.well-known/jmap");
|
||||
|
||||
|
|
|
@ -64,7 +64,7 @@ pub trait Method<OBJ: Object>: Serialize {
|
|||
const NAME: &'static str;
|
||||
}
|
||||
|
||||
static USING: &'static [&'static str] = &["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"];
|
||||
static USING: &[&str] = &["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"];
|
||||
|
||||
#[derive(Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
@ -208,9 +208,7 @@ pub fn get_message_list(conn: &JmapConnection, mailbox: &JmapMailbox) -> Result<
|
|||
pub fn get_message(conn: &JmapConnection, ids: &[String]) -> Result<Vec<Envelope>> {
|
||||
let email_call: EmailGet = EmailGet::new(
|
||||
Get::new()
|
||||
.ids(Some(JmapArgument::value(
|
||||
ids.iter().cloned().collect::<Vec<String>>(),
|
||||
)))
|
||||
.ids(Some(JmapArgument::value(ids.to_vec())))
|
||||
.account_id(conn.mail_account_id().to_string()),
|
||||
);
|
||||
|
||||
|
|
|
@ -166,10 +166,10 @@ impl<OBJ: Object + Serialize + std::fmt::Debug> Serialize for Get<OBJ> {
|
|||
if !self.account_id.is_empty() {
|
||||
fields_no += 1;
|
||||
}
|
||||
if !self.ids.is_none() {
|
||||
if self.ids.is_some() {
|
||||
fields_no += 1;
|
||||
}
|
||||
if !self.properties.is_none() {
|
||||
if self.properties.is_some() {
|
||||
fields_no += 1;
|
||||
}
|
||||
|
||||
|
@ -204,7 +204,7 @@ impl<OBJ: Object + Serialize + std::fmt::Debug> Serialize for Get<OBJ> {
|
|||
}
|
||||
}
|
||||
|
||||
if !self.properties.is_none() {
|
||||
if self.properties.is_some() {
|
||||
state.serialize_field("properties", self.properties.as_ref().unwrap())?;
|
||||
}
|
||||
|
||||
|
|
|
@ -283,10 +283,7 @@ impl MailBackend for MaildirType {
|
|||
let op = Box::new(MaildirOp::new(hash, map.clone(), mailbox_hash));
|
||||
if let Ok(e) = Envelope::from_token(op, hash) {
|
||||
mailbox_index.lock().unwrap().insert(e.hash(), mailbox_hash);
|
||||
let file_name = PathBuf::from(file)
|
||||
.strip_prefix(&root_path)
|
||||
.unwrap()
|
||||
.to_path_buf();
|
||||
let file_name = file.strip_prefix(&root_path).unwrap().to_path_buf();
|
||||
if let Ok(cached) = cache_dir.place_cache_file(file_name) {
|
||||
/* place result in cache directory */
|
||||
let f = match fs::File::create(cached) {
|
||||
|
@ -449,7 +446,6 @@ impl MailBackend for MaildirType {
|
|||
*v = pathbuf.clone().into();
|
||||
*k
|
||||
} else {
|
||||
drop(index_lock);
|
||||
drop(hash_indexes_lock);
|
||||
/* Did we just miss a Create event? In any case, create
|
||||
* envelope. */
|
||||
|
@ -608,7 +604,6 @@ impl MailBackend for MaildirType {
|
|||
.unwrap()
|
||||
.to_path_buf();
|
||||
debug!("filename = {:?}", file_name);
|
||||
drop(index_lock);
|
||||
drop(hash_indexes_lock);
|
||||
if let Some(env) = add_path_to_index(
|
||||
&hash_indexes,
|
||||
|
@ -813,10 +808,11 @@ impl MaildirType {
|
|||
&settings,
|
||||
) {
|
||||
f.children = recurse_mailboxes(mailboxes, settings, &path)?;
|
||||
f.children
|
||||
.iter()
|
||||
.map(|c| mailboxes.get_mut(c).map(|f| f.parent = Some(f.hash)))
|
||||
.count();
|
||||
for c in &f.children {
|
||||
if let Some(f) = mailboxes.get_mut(c) {
|
||||
f.parent = Some(f.hash);
|
||||
}
|
||||
}
|
||||
children.push(f.hash);
|
||||
mailboxes.insert(f.hash, f);
|
||||
} else {
|
||||
|
@ -834,14 +830,11 @@ impl MaildirType {
|
|||
true,
|
||||
&settings,
|
||||
) {
|
||||
f.children
|
||||
.iter()
|
||||
.map(|c| {
|
||||
mailboxes
|
||||
.get_mut(c)
|
||||
.map(|f| f.parent = Some(f.hash))
|
||||
})
|
||||
.count();
|
||||
for c in &f.children {
|
||||
if let Some(f) = mailboxes.get_mut(c) {
|
||||
f.parent = Some(f.hash);
|
||||
}
|
||||
}
|
||||
children.push(f.hash);
|
||||
mailboxes.insert(f.hash, f);
|
||||
}
|
||||
|
@ -881,18 +874,22 @@ impl MaildirType {
|
|||
|
||||
if mailboxes.is_empty() {
|
||||
let children = recurse_mailboxes(&mut mailboxes, settings, &root_path)?;
|
||||
children
|
||||
.iter()
|
||||
.map(|c| mailboxes.get_mut(c).map(|f| f.parent = None))
|
||||
.count();
|
||||
for c in &children {
|
||||
if let Some(f) = mailboxes.get_mut(c) {
|
||||
f.parent = None;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let root_hash = *mailboxes.keys().nth(0).unwrap();
|
||||
let root_hash = *mailboxes.keys().next().unwrap();
|
||||
let children = recurse_mailboxes(&mut mailboxes, settings, &root_path)?;
|
||||
children
|
||||
.iter()
|
||||
.map(|c| mailboxes.get_mut(c).map(|f| f.parent = Some(root_hash)))
|
||||
.count();
|
||||
mailboxes.get_mut(&root_hash).map(|f| f.children = children);
|
||||
for c in &children {
|
||||
if let Some(f) = mailboxes.get_mut(c) {
|
||||
f.parent = Some(root_hash);
|
||||
}
|
||||
}
|
||||
if let Some(f) = mailboxes.get_mut(&root_hash) {
|
||||
f.children = children;
|
||||
}
|
||||
}
|
||||
for f in mailboxes.values_mut() {
|
||||
if is_subscribed(f.path()) {
|
||||
|
@ -1176,7 +1173,7 @@ impl MaildirType {
|
|||
|
||||
let mut writer = io::BufWriter::new(file);
|
||||
writer.write_all(&bytes).unwrap();
|
||||
return Ok(());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn validate_config(s: &AccountSettings) -> Result<()> {
|
||||
|
|
|
@ -105,11 +105,6 @@ impl MaildirStream {
|
|||
map: HashIndexes,
|
||||
mailbox_index: Arc<Mutex<HashMap<EnvelopeHash, MailboxHash>>>,
|
||||
) -> Result<Vec<Envelope>> {
|
||||
let unseen = unseen.clone();
|
||||
let total = total.clone();
|
||||
let map = map.clone();
|
||||
let mailbox_index = mailbox_index.clone();
|
||||
let root_path = root_path.clone();
|
||||
let len = chunk.len();
|
||||
let size = if len <= 100 { 100 } else { (len / 100) * 100 };
|
||||
let mut local_r: Vec<Envelope> = Vec::with_capacity(chunk.len());
|
||||
|
|
|
@ -31,7 +31,6 @@ use crate::email::*;
|
|||
use crate::error::{MeliError, Result};
|
||||
use crate::get_path_hash;
|
||||
use crate::shellexpand::ShellExpandTrait;
|
||||
use libc;
|
||||
use memmap::{Mmap, Protection};
|
||||
use nom::bytes::complete::tag;
|
||||
use nom::character::complete::digit1;
|
||||
|
@ -324,33 +323,33 @@ impl MboxReader {
|
|||
Ok(mut env) => {
|
||||
let mut flags = Flag::empty();
|
||||
if env.other_headers().contains_key("Status") {
|
||||
if env.other_headers()["Status"].contains("F") {
|
||||
if env.other_headers()["Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("A") {
|
||||
if env.other_headers()["Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("R") {
|
||||
if env.other_headers()["Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("D") {
|
||||
if env.other_headers()["Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
}
|
||||
if env.other_headers().contains_key("X-Status") {
|
||||
if env.other_headers()["X-Status"].contains("F") {
|
||||
if env.other_headers()["X-Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("A") {
|
||||
if env.other_headers()["X-Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("R") {
|
||||
if env.other_headers()["X-Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("D") {
|
||||
if env.other_headers()["X-Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("T") {
|
||||
if env.other_headers()["X-Status"].contains('T') {
|
||||
flags.set(Flag::DRAFT, true);
|
||||
}
|
||||
}
|
||||
|
@ -422,33 +421,33 @@ impl MboxReader {
|
|||
Ok(mut env) => {
|
||||
let mut flags = Flag::empty();
|
||||
if env.other_headers().contains_key("Status") {
|
||||
if env.other_headers()["Status"].contains("F") {
|
||||
if env.other_headers()["Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("A") {
|
||||
if env.other_headers()["Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("R") {
|
||||
if env.other_headers()["Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("D") {
|
||||
if env.other_headers()["Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
}
|
||||
if env.other_headers().contains_key("X-Status") {
|
||||
if env.other_headers()["X-Status"].contains("F") {
|
||||
if env.other_headers()["X-Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("A") {
|
||||
if env.other_headers()["X-Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("R") {
|
||||
if env.other_headers()["X-Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("D") {
|
||||
if env.other_headers()["X-Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("T") {
|
||||
if env.other_headers()["X-Status"].contains('T') {
|
||||
flags.set(Flag::DRAFT, true);
|
||||
}
|
||||
}
|
||||
|
@ -471,33 +470,33 @@ impl MboxReader {
|
|||
Ok(mut env) => {
|
||||
let mut flags = Flag::empty();
|
||||
if env.other_headers().contains_key("Status") {
|
||||
if env.other_headers()["Status"].contains("F") {
|
||||
if env.other_headers()["Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("A") {
|
||||
if env.other_headers()["Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("R") {
|
||||
if env.other_headers()["Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["Status"].contains("D") {
|
||||
if env.other_headers()["Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
}
|
||||
if env.other_headers().contains_key("X-Status") {
|
||||
if env.other_headers()["X-Status"].contains("F") {
|
||||
if env.other_headers()["X-Status"].contains('F') {
|
||||
flags.set(Flag::FLAGGED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("A") {
|
||||
if env.other_headers()["X-Status"].contains('A') {
|
||||
flags.set(Flag::REPLIED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("R") {
|
||||
if env.other_headers()["X-Status"].contains('R') {
|
||||
flags.set(Flag::SEEN, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("D") {
|
||||
if env.other_headers()["X-Status"].contains('D') {
|
||||
flags.set(Flag::TRASHED, true);
|
||||
}
|
||||
if env.other_headers()["X-Status"].contains("T") {
|
||||
if env.other_headers()["X-Status"].contains('T') {
|
||||
flags.set(Flag::DRAFT, true);
|
||||
}
|
||||
}
|
||||
|
@ -583,9 +582,7 @@ impl MboxReader {
|
|||
Ok((input, env))
|
||||
}
|
||||
}
|
||||
Err(_err) => {
|
||||
return Self::MboxRd.parse(orig_input);
|
||||
}
|
||||
Err(_err) => Self::MboxRd.parse(orig_input),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -621,7 +618,7 @@ pub fn mbox_parse(
|
|||
offset += 2;
|
||||
}
|
||||
} else {
|
||||
Err(e)?;
|
||||
return Err(e);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
@ -636,7 +633,7 @@ pub fn mbox_parse(
|
|||
|
||||
envelopes.push(env);
|
||||
}
|
||||
return Ok((&[], envelopes));
|
||||
Ok((&[], envelopes))
|
||||
}
|
||||
|
||||
/// Mbox backend
|
||||
|
@ -662,7 +659,7 @@ impl MailBackend for MboxType {
|
|||
let mailbox_index = self.mailbox_index.clone();
|
||||
let mailboxes = self.mailboxes.clone();
|
||||
let mailbox_path = mailboxes.lock().unwrap()[&mailbox_hash].fs_path.clone();
|
||||
let prefer_mbox_type = self.prefer_mbox_type.clone();
|
||||
let prefer_mbox_type = self.prefer_mbox_type;
|
||||
let closure = move |_work_context| {
|
||||
let tx = tx.clone();
|
||||
let file = match std::fs::OpenOptions::new()
|
||||
|
@ -691,7 +688,7 @@ impl MailBackend for MboxType {
|
|||
let index = mailboxes_lck[&mailbox_hash].index.clone();
|
||||
drop(mailboxes_lck);
|
||||
let payload = mbox_parse(index, contents.as_slice(), 0, prefer_mbox_type)
|
||||
.map_err(|e| MeliError::from(e))
|
||||
.map_err(MeliError::from)
|
||||
.map(|(_, v)| {
|
||||
for v in v.iter() {
|
||||
mailbox_index_lck.insert(v.hash(), mailbox_hash);
|
||||
|
@ -735,7 +732,7 @@ impl MailBackend for MboxType {
|
|||
hasher.finish()
|
||||
};
|
||||
let mailboxes = self.mailboxes.clone();
|
||||
let prefer_mbox_type = self.prefer_mbox_type.clone();
|
||||
let prefer_mbox_type = self.prefer_mbox_type;
|
||||
let handle = std::thread::Builder::new()
|
||||
.name(format!("watching {}", self.account_name,))
|
||||
.spawn(move || {
|
||||
|
@ -813,7 +810,7 @@ impl MailBackend for MboxType {
|
|||
.lock()
|
||||
.unwrap()
|
||||
.values()
|
||||
.any(|f| &f.fs_path == &pathbuf)
|
||||
.any(|f| f.fs_path == pathbuf)
|
||||
{
|
||||
let mailbox_hash = get_path_hash!(&pathbuf);
|
||||
sender.send(RefreshEvent {
|
||||
|
@ -971,7 +968,7 @@ impl MboxType {
|
|||
.path
|
||||
.file_name()
|
||||
.map(|f| f.to_string_lossy().into())
|
||||
.unwrap_or(String::new());
|
||||
.unwrap_or_default();
|
||||
let hash = get_path_hash!(&ret.path);
|
||||
|
||||
let read_only = if let Ok(metadata) = std::fs::metadata(&ret.path) {
|
||||
|
|
|
@ -189,7 +189,7 @@ impl NotmuchDb {
|
|||
_is_subscribed: Box<dyn Fn(&str) -> bool>,
|
||||
) -> Result<Box<dyn MailBackend>> {
|
||||
let lib = Arc::new(libloading::Library::new("libnotmuch.so.5")?);
|
||||
let path = Path::new(s.root_mailbox.as_str()).expand().to_path_buf();
|
||||
let path = Path::new(s.root_mailbox.as_str()).expand();
|
||||
if !path.exists() {
|
||||
return Err(MeliError::new(format!(
|
||||
"\"root_mailbox\" {} for account {} is not a valid path.",
|
||||
|
@ -243,7 +243,7 @@ impl NotmuchDb {
|
|||
}
|
||||
|
||||
pub fn validate_config(s: &AccountSettings) -> Result<()> {
|
||||
let path = Path::new(s.root_mailbox.as_str()).expand().to_path_buf();
|
||||
let path = Path::new(s.root_mailbox.as_str()).expand();
|
||||
if !path.exists() {
|
||||
return Err(MeliError::new(format!(
|
||||
"\"root_mailbox\" {} for account {} is not a valid path.",
|
||||
|
@ -580,7 +580,7 @@ impl MailBackend for NotmuchDb {
|
|||
sender.send(RefreshEvent {
|
||||
account_hash,
|
||||
mailbox_hash: 0,
|
||||
kind: Failure(err.into()),
|
||||
kind: Failure(err),
|
||||
});
|
||||
}
|
||||
})?;
|
||||
|
@ -788,13 +788,11 @@ impl BackendOp for NotmuchOp {
|
|||
index_lck[&self.hash]
|
||||
)));
|
||||
}
|
||||
let c_tag = CString::new(tag.as_str()).unwrap();
|
||||
if value {
|
||||
if let Err(err) = try_call!(
|
||||
self.lib,
|
||||
call!(self.lib, notmuch_message_add_tag)(
|
||||
message,
|
||||
CString::new(tag.as_str()).unwrap().as_ptr(),
|
||||
)
|
||||
call!(self.lib, notmuch_message_add_tag)(message, c_tag.as_ptr(),)
|
||||
) {
|
||||
return Err(MeliError::new("Could not set tag.").set_source(Some(Arc::new(err))));
|
||||
}
|
||||
|
@ -802,10 +800,7 @@ impl BackendOp for NotmuchOp {
|
|||
} else {
|
||||
if let Err(err) = try_call!(
|
||||
self.lib,
|
||||
call!(self.lib, notmuch_message_remove_tag)(
|
||||
message,
|
||||
CString::new(tag.as_str()).unwrap().as_ptr(),
|
||||
)
|
||||
call!(self.lib, notmuch_message_remove_tag)(message, c_tag.as_ptr(),)
|
||||
) {
|
||||
return Err(MeliError::new("Could not set tag.").set_source(Some(Arc::new(err))));
|
||||
}
|
||||
|
|
|
@ -422,12 +422,12 @@ impl Collection {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn get_env<'g>(&'g self, env_hash: EnvelopeHash) -> EnvelopeRef<'g> {
|
||||
let guard: RwLockReadGuard<'g, _> = self.envelopes.read().unwrap();
|
||||
pub fn get_env(&'_ self, env_hash: EnvelopeHash) -> EnvelopeRef<'_> {
|
||||
let guard: RwLockReadGuard<'_, _> = self.envelopes.read().unwrap();
|
||||
EnvelopeRef { guard, env_hash }
|
||||
}
|
||||
|
||||
pub fn get_env_mut<'g>(&'g mut self, env_hash: EnvelopeHash) -> EnvelopeRefMut<'g> {
|
||||
pub fn get_env_mut(&'_ mut self, env_hash: EnvelopeHash) -> EnvelopeRefMut<'_> {
|
||||
let guard = self.envelopes.write().unwrap();
|
||||
EnvelopeRefMut { guard, env_hash }
|
||||
}
|
||||
|
|
|
@ -56,7 +56,7 @@ pub fn timestamp_to_string(timestamp: UnixTimestamp, fmt: Option<&str>) -> Strin
|
|||
localtime_r(&i as *const i64, &mut new_tm as *mut ::libc::tm);
|
||||
}
|
||||
let fmt = fmt
|
||||
.map(|slice| CString::new(slice))
|
||||
.map(CString::new)
|
||||
.map(|res| res.ok())
|
||||
.and_then(|opt| opt);
|
||||
let format: &CStr = if let Some(ref s) = fmt {
|
||||
|
@ -139,13 +139,11 @@ fn year_to_secs(year: i64, is_leap: &mut bool) -> std::result::Result<i64, ()> {
|
|||
centuries = 2;
|
||||
rem -= 200;
|
||||
}
|
||||
} else if rem >= 100 {
|
||||
centuries = 1;
|
||||
rem -= 100;
|
||||
} else {
|
||||
if rem >= 100 {
|
||||
centuries = 1;
|
||||
rem -= 100;
|
||||
} else {
|
||||
centuries = 0;
|
||||
}
|
||||
centuries = 0;
|
||||
}
|
||||
if rem == 0 {
|
||||
*is_leap = false;
|
||||
|
@ -159,10 +157,10 @@ fn year_to_secs(year: i64, is_leap: &mut bool) -> std::result::Result<i64, ()> {
|
|||
|
||||
leaps += 97 * cycles + 24 * centuries - if *is_leap { 1 } else { 0 };
|
||||
|
||||
return Ok(match (year - 100).overflowing_mul(31536000) {
|
||||
(_, true) => return Err(()),
|
||||
(res, false) => res + leaps * 86400 + 946684800 + 86400,
|
||||
});
|
||||
match (year - 100).overflowing_mul(31536000) {
|
||||
(_, true) => Err(()),
|
||||
(res, false) => Ok(res + leaps * 86400 + 946684800 + 86400),
|
||||
}
|
||||
}
|
||||
|
||||
fn month_to_secs(month: usize, is_leap: bool) -> i64 {
|
||||
|
@ -184,7 +182,7 @@ fn month_to_secs(month: usize, is_leap: bool) -> i64 {
|
|||
if is_leap && month >= 2 {
|
||||
t += 86400;
|
||||
}
|
||||
return t;
|
||||
t
|
||||
}
|
||||
|
||||
pub fn rfc822_to_timestamp<T>(s: T) -> Result<UnixTimestamp>
|
||||
|
@ -239,7 +237,7 @@ where
|
|||
.unwrap_or(0));
|
||||
}
|
||||
}
|
||||
return Ok(0);
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
pub fn rfc3339_to_timestamp<T>(s: T) -> Result<UnixTimestamp>
|
||||
|
@ -292,7 +290,7 @@ where
|
|||
.unwrap_or(0));
|
||||
}
|
||||
}
|
||||
return Ok(0);
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
// FIXME: Handle non-local timezone?
|
||||
|
@ -311,7 +309,7 @@ where
|
|||
if ret.is_null() {
|
||||
return Ok(None);
|
||||
}
|
||||
return Ok(Some(mktime(&new_tm as *const _) as u64));
|
||||
Ok(Some(mktime(&new_tm as *const _) as u64))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -443,7 +441,8 @@ fn test_rfcs() {
|
|||
);
|
||||
}
|
||||
|
||||
const TIMEZONE_ABBR: &'static [(&'static [u8], (i8, i8))] = &[
|
||||
#[allow(clippy::zero_prefixed_literal)]
|
||||
const TIMEZONE_ABBR: &[(&[u8], (i8, i8))] = &[
|
||||
(b"ACDT", (10, 30)),
|
||||
(b"ACST", (09, 30)),
|
||||
(b"ACT", (-05, 0)),
|
||||
|
|
|
@ -340,15 +340,15 @@ fn build_multipart(ret: &mut String, kind: MultipartType, parts: Vec<AttachmentB
|
|||
);
|
||||
ret.push('\n');
|
||||
/* rfc1341 */
|
||||
ret.extend("This is a MIME formatted message with attachments. Use a MIME-compliant client to view it properly.\n".chars());
|
||||
ret.push_str("This is a MIME formatted message with attachments. Use a MIME-compliant client to view it properly.\n");
|
||||
for sub in parts {
|
||||
ret.push_str("--");
|
||||
ret.extend(boundary.chars());
|
||||
ret.push_str(&boundary);
|
||||
ret.push('\n');
|
||||
print_attachment(ret, &kind, sub);
|
||||
}
|
||||
ret.push_str("--");
|
||||
ret.extend(boundary.chars());
|
||||
ret.push_str(&boundary);
|
||||
ret.push_str("--\n");
|
||||
}
|
||||
|
||||
|
@ -365,7 +365,7 @@ fn print_attachment(ret: &mut String, kind: &MultipartType, a: AttachmentBuilder
|
|||
ret.push('\n');
|
||||
}
|
||||
Text { .. } => {
|
||||
ret.extend(a.build().into_raw().chars());
|
||||
ret.push_str(&a.build().into_raw());
|
||||
ret.push('\n');
|
||||
}
|
||||
Multipart {
|
||||
|
@ -384,7 +384,7 @@ fn print_attachment(ret: &mut String, kind: &MultipartType, a: AttachmentBuilder
|
|||
ret.push('\n');
|
||||
}
|
||||
MessageRfc822 | PGPSignature => {
|
||||
ret.extend(format!("Content-Type: {}; charset=\"utf-8\"\n", kind).chars());
|
||||
ret.push_str(&format!("Content-Type: {}; charset=\"utf-8\"\n", kind));
|
||||
ret.push('\n');
|
||||
ret.push_str(&String::from_utf8_lossy(a.raw()));
|
||||
ret.push('\n');
|
||||
|
|
|
@ -41,16 +41,14 @@ pub fn encode_header(value: &str) -> String {
|
|||
*
|
||||
* Whitespaces inside encoded tokens must be greedily taken,
|
||||
* instead of splitting each non-ascii word into separate encoded tokens. */
|
||||
if !g.split_whitespace().collect::<Vec<&str>>().is_empty() {
|
||||
if !g.split_whitespace().next().is_none() {
|
||||
ret.push_str(&format!(
|
||||
"=?UTF-8?B?{}?=",
|
||||
BASE64_MIME
|
||||
.encode(value[current_window_start..idx].as_bytes())
|
||||
.trim()
|
||||
));
|
||||
if idx != value.len() - 1
|
||||
&& (idx == 0 || value[..idx].chars().last() != Some(' '))
|
||||
{
|
||||
if idx != value.len() - 1 && (idx == 0 || !value[..idx].ends_with(' ')) {
|
||||
ret.push(' ');
|
||||
}
|
||||
is_current_window_ascii = true;
|
||||
|
|
|
@ -61,7 +61,7 @@ impl<'a> ListAction<'a> {
|
|||
});
|
||||
|
||||
vec.into_iter()
|
||||
.map(|elem| ListAction::from(elem))
|
||||
.map(ListAction::from)
|
||||
.collect::<SmallVec<[ListAction<'a>; 4]>>()
|
||||
})
|
||||
.ok()
|
||||
|
@ -85,20 +85,20 @@ pub struct ListActions<'a> {
|
|||
pub unsubscribe: Option<SmallVec<[ListAction<'a>; 4]>>,
|
||||
}
|
||||
|
||||
pub fn list_id_header<'a>(envelope: &'a Envelope) -> Option<&'a str> {
|
||||
pub fn list_id_header(envelope: &'_ Envelope) -> Option<&'_ str> {
|
||||
envelope
|
||||
.other_headers()
|
||||
.get("List-ID")
|
||||
.or(envelope.other_headers().get("List-Id"))
|
||||
.or_else(|| envelope.other_headers().get("List-Id"))
|
||||
.map(String::as_str)
|
||||
}
|
||||
|
||||
pub fn list_id<'a>(header: Option<&'a str>) -> Option<&'a str> {
|
||||
pub fn list_id(header: Option<&'_ str>) -> Option<&'_ str> {
|
||||
/* rfc2919 https://tools.ietf.org/html/rfc2919 */
|
||||
/* list-id-header = "List-ID:" [phrase] "<" list-id ">" CRLF */
|
||||
header.and_then(|v| {
|
||||
if let Some(l) = v.rfind("<") {
|
||||
if let Some(r) = v.rfind(">") {
|
||||
if let Some(l) = v.rfind('<') {
|
||||
if let Some(r) = v.rfind('>') {
|
||||
if l < r {
|
||||
return Some(&v[l + 1..r]);
|
||||
}
|
||||
|
@ -115,8 +115,8 @@ impl<'a> ListActions<'a> {
|
|||
ret.id = list_id_header(envelope);
|
||||
|
||||
if let Some(archive) = envelope.other_headers().get("List-Archive") {
|
||||
if archive.starts_with("<") {
|
||||
if let Some(pos) = archive.find(">") {
|
||||
if archive.starts_with('<') {
|
||||
if let Some(pos) = archive.find('>') {
|
||||
ret.archive = Some(&archive[1..pos]);
|
||||
} else {
|
||||
ret.archive = Some(archive);
|
||||
|
|
|
@ -41,10 +41,10 @@ impl From<Mailto> for Draft {
|
|||
bcc,
|
||||
body,
|
||||
} = val;
|
||||
ret.set_header("Subject", subject.unwrap_or(String::new()));
|
||||
ret.set_header("Cc", cc.unwrap_or(String::new()));
|
||||
ret.set_header("Bcc", bcc.unwrap_or(String::new()));
|
||||
ret.set_body(body.unwrap_or(String::new()));
|
||||
ret.set_header("Subject", subject.unwrap_or_default());
|
||||
ret.set_header("Cc", cc.unwrap_or_default());
|
||||
ret.set_header("Bcc", bcc.unwrap_or_default());
|
||||
ret.set_body(body.unwrap_or_default());
|
||||
ret.set_header("To", address.to_string());
|
||||
debug!(ret)
|
||||
}
|
||||
|
@ -55,8 +55,8 @@ impl TryFrom<&[u8]> for Mailto {
|
|||
|
||||
fn try_from(value: &[u8]) -> std::result::Result<Self, Self::Error> {
|
||||
let parse_res = super::parser::generic::mailto(value).map(|(_, v)| v);
|
||||
if parse_res.is_ok() {
|
||||
Ok(parse_res.unwrap())
|
||||
if let Ok(res) = parse_res {
|
||||
Ok(res)
|
||||
} else {
|
||||
debug!(
|
||||
"parser::mailto returned error while parsing {}:\n{:?}",
|
||||
|
|
|
@ -998,9 +998,9 @@ pub mod encodings {
|
|||
|
||||
fn quoted_printable_soft_break(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
||||
if input.len() < 2 {
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "quoted_printable_soft_break(): found EOF").into(),
|
||||
));
|
||||
))
|
||||
} else if input[0] == b'=' && input[1] == b'\n' {
|
||||
Ok((&input[2..], &input[0..2])) // `=\n` is an escaped space character.
|
||||
} else if input.len() > 3 && input.starts_with(b"=\r\n") {
|
||||
|
@ -1158,7 +1158,7 @@ pub mod address {
|
|||
use crate::email::address::*;
|
||||
pub fn display_addr(input: &[u8]) -> IResult<&[u8], Address> {
|
||||
if input.is_empty() || input.len() < 3 {
|
||||
return Err(nom::Err::Error((input, "display_addr(): EOF").into()));
|
||||
Err(nom::Err::Error((input, "display_addr(): EOF").into()))
|
||||
} else if !is_whitespace!(input[0]) {
|
||||
let mut display_name = StrBuilder {
|
||||
offset: 0,
|
||||
|
@ -1260,7 +1260,7 @@ pub mod address {
|
|||
|
||||
fn addr_spec(input: &[u8]) -> IResult<&[u8], Address> {
|
||||
if input.is_empty() || input.len() < 3 {
|
||||
return Err(nom::Err::Error((input, "addr_spec(): found EOF").into()));
|
||||
Err(nom::Err::Error((input, "addr_spec(): found EOF").into()))
|
||||
} else if !is_whitespace!(input[0]) {
|
||||
let mut end = input[1..].len();
|
||||
let mut flag = false;
|
||||
|
@ -1394,22 +1394,22 @@ pub mod address {
|
|||
fn message_id_peek(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
||||
let input_length = input.len();
|
||||
if input.is_empty() {
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "message_id_peek(): found EOF").into(),
|
||||
));
|
||||
))
|
||||
} else if input_length == 2 || input[0] != b'<' {
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "message_id_peek(): expected '<'").into(),
|
||||
));
|
||||
))
|
||||
} else {
|
||||
for (i, &x) in input.iter().take(input_length).enumerate().skip(1) {
|
||||
if x == b'>' {
|
||||
return Ok((&input[i + 1..], &input[0..=i]));
|
||||
}
|
||||
}
|
||||
return Err(nom::Err::Error(
|
||||
Err(nom::Err::Error(
|
||||
(input, "message_id_peek(): expected closing '>'").into(),
|
||||
));
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -112,7 +112,7 @@ impl MeliError {
|
|||
impl fmt::Display for MeliError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
if let Some(summary) = self.summary.as_ref() {
|
||||
write!(f, "Summary: {}\n", summary)?;
|
||||
writeln!(f, "Summary: {}", summary)?;
|
||||
}
|
||||
let ret = write!(f, "{}", self.details)?;
|
||||
if let Some(source) = self.source.as_ref() {
|
||||
|
|
|
@ -291,7 +291,7 @@ pub mod shellexpand {
|
|||
// the end of the directory listing, right? Unfortunately, no. SYS_getdents64 is finicky.
|
||||
// It sometimes writes a partial list of entries even if the full list would fit."
|
||||
}
|
||||
return entries;
|
||||
entries
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
|
|
|
@ -754,7 +754,7 @@ pub use alg::linear;
|
|||
mod alg {
|
||||
use super::super::grapheme_clusters::TextProcessing;
|
||||
use super::super::*;
|
||||
fn cost(i: usize, j: usize, width: usize, minima: &Vec<usize>, offsets: &Vec<usize>) -> usize {
|
||||
fn cost(i: usize, j: usize, width: usize, minima: &[usize], offsets: &[usize]) -> usize {
|
||||
let w = offsets[j] + j - offsets[i] - i - 1;
|
||||
if w > width {
|
||||
return 65536 * (w - width);
|
||||
|
@ -773,7 +773,7 @@ mod alg {
|
|||
let mut stack = Vec::new();
|
||||
let mut i = 0;
|
||||
while i < rows.len() {
|
||||
if stack.len() > 0 {
|
||||
if !stack.is_empty() {
|
||||
let c = columns[stack.len() - 1];
|
||||
if cost(*stack.iter().last().unwrap(), c, width, minima, offsets)
|
||||
< cost(rows[i], c, width, minima, offsets)
|
||||
|
@ -826,12 +826,12 @@ mod alg {
|
|||
{
|
||||
let mut prev = 0;
|
||||
for b in breaks {
|
||||
if text[prev..b.0].ends_with("\n") && text[b.0..].starts_with("\n") {
|
||||
words.push(text[prev..b.0].trim_end_matches("\n"));
|
||||
if text[prev..b.0].ends_with('\n') && text[b.0..].starts_with('\n') {
|
||||
words.push(text[prev..b.0].trim_end_matches('\n'));
|
||||
words.push("\n\n");
|
||||
} else if &text[prev..b.0] != "\n" {
|
||||
words.push(text[prev..b.0].trim_end_matches("\n"));
|
||||
if text[prev..b.0].ends_with("\n") {
|
||||
words.push(text[prev..b.0].trim_end_matches('\n'));
|
||||
if text[prev..b.0].ends_with('\n') {
|
||||
words.push(" ");
|
||||
}
|
||||
}
|
||||
|
@ -922,7 +922,7 @@ pub fn split_lines_reflow(text: &str, reflow: Reflow, width: Option<usize>) -> V
|
|||
* - Split lines with indices using str::match_indices()
|
||||
* - Iterate and reflow flow regions, and pass fixed regions through
|
||||
*/
|
||||
let lines_indices: Vec<usize> = text.match_indices("\n").map(|(i, _)| i).collect();
|
||||
let lines_indices: Vec<usize> = text.match_indices('\n').map(|(i, _)| i).collect();
|
||||
let mut prev_index = 0;
|
||||
let mut in_paragraph = false;
|
||||
let mut paragraph_start = 0;
|
||||
|
@ -946,7 +946,7 @@ pub fn split_lines_reflow(text: &str, reflow: Reflow, width: Option<usize>) -> V
|
|||
})
|
||||
.unwrap_or(0);
|
||||
trimmed = &trimmed[p_str..];
|
||||
if trimmed.starts_with(" ") {
|
||||
if trimmed.starts_with(' ') {
|
||||
/* Remove space stuffing before checking for ending space character.
|
||||
* [rfc3676#section-4.4] */
|
||||
trimmed = &trimmed[1..];
|
||||
|
@ -999,7 +999,6 @@ pub fn split_lines_reflow(text: &str, reflow: Reflow, width: Option<usize>) -> V
|
|||
|
||||
let breaks = LineBreakCandidateIter::new(line)
|
||||
.collect::<Vec<(usize, LineBreakCandidate)>>();
|
||||
&breaks.iter().enumerate().collect::<Vec<_>>();
|
||||
if breaks.len() < 2 {
|
||||
split(&mut ret, line, width);
|
||||
continue;
|
||||
|
@ -1021,7 +1020,7 @@ pub fn split_lines_reflow(text: &str, reflow: Reflow, width: Option<usize>) -> V
|
|||
};
|
||||
if !line[prev_line_offset..end_offset].is_empty() {
|
||||
if prev_line_offset == 0 {
|
||||
ret.push(format!("{}", &line[prev_line_offset..end_offset]));
|
||||
ret.push(line[prev_line_offset..end_offset].to_string());
|
||||
} else {
|
||||
ret.push(format!("⤷{}", &line[prev_line_offset..end_offset]));
|
||||
}
|
||||
|
@ -1046,7 +1045,7 @@ fn split(ret: &mut Vec<String>, mut line: &str, width: usize) {
|
|||
while !line.is_empty() {
|
||||
let mut chop_index = std::cmp::min(line.len().saturating_sub(1), width);
|
||||
while chop_index > 0 && !line.is_char_boundary(chop_index) {
|
||||
chop_index = chop_index - 1;
|
||||
chop_index -= 1;
|
||||
}
|
||||
if chop_index == 0 {
|
||||
ret.push(format!("⤷{}", line));
|
||||
|
@ -1113,11 +1112,11 @@ easy to take MORE than nothing.'"#;
|
|||
for l in split_lines_reflow(text, Reflow::FormatFlowed, Some(30)) {
|
||||
println!("{}", l);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
for l in split_lines_reflow(text, Reflow::No, Some(30)) {
|
||||
println!("{}", l);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
let text = r#">>>Take some more tea.
|
||||
>>I've had nothing yet, so I can't take more.
|
||||
>You mean you can't take LESS, it's very easy to take
|
||||
|
@ -1125,11 +1124,11 @@ easy to take MORE than nothing.'"#;
|
|||
for l in split_lines_reflow(text, Reflow::FormatFlowed, Some(20)) {
|
||||
println!("{}", l);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
for l in split_lines_reflow(text, Reflow::No, Some(20)) {
|
||||
println!("{}", l);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
use super::_ALICE_CHAPTER_1;
|
||||
for l in split_lines_reflow(_ALICE_CHAPTER_1, Reflow::FormatFlowed, Some(72)) {
|
||||
println!("{}", l);
|
||||
|
|
|
@ -139,7 +139,7 @@ fn test_globmatch() {
|
|||
assert!(!"INBOX/Lists/".matches_glob("INBOX/Lists/*"));
|
||||
}
|
||||
|
||||
pub const _ALICE_CHAPTER_1: &'static str = r#"CHAPTER I. Down the Rabbit-Hole
|
||||
pub const _ALICE_CHAPTER_1: &str = r#"CHAPTER I. Down the Rabbit-Hole
|
||||
|
||||
Alice was beginning to get very tired of sitting by her sister on the
|
||||
bank, and of having nothing to do: once or twice she had peeped into the
|
||||
|
|
|
@ -22,7 +22,7 @@
|
|||
use super::types::LineBreakClass;
|
||||
use super::types::LineBreakClass::*;
|
||||
|
||||
pub const LINE_BREAK_RULES: &'static [(u32, u32, LineBreakClass)] = &[
|
||||
pub const LINE_BREAK_RULES: &[(u32, u32, LineBreakClass)] = &[
|
||||
(0x0, 0x8, CM),
|
||||
(0x9, 0x9, BA),
|
||||
(0xA, 0xA, LF),
|
||||
|
|
|
@ -169,7 +169,7 @@ fn bisearch(ucs: WChar, table: &'static [Interval]) -> bool {
|
|||
|
||||
pub fn wcwidth(ucs: WChar) -> Option<usize> {
|
||||
/* sorted list of non-overlapping intervals of non-spacing characters */
|
||||
let combining: &'static [Interval] = &[
|
||||
const COMBINING: &[Interval] = &[
|
||||
(0x0300, 0x034E),
|
||||
(0x0360, 0x0362),
|
||||
(0x0483, 0x0486),
|
||||
|
@ -285,7 +285,7 @@ pub fn wcwidth(ucs: WChar) -> Option<usize> {
|
|||
return Some(2);
|
||||
}
|
||||
/* binary search in table of non-spacing characters */
|
||||
if bisearch(ucs, combining) {
|
||||
if bisearch(ucs, COMBINING) {
|
||||
return Some(1);
|
||||
}
|
||||
|
||||
|
@ -324,7 +324,7 @@ pub fn wcswidth(mut pwcs: WChar, mut n: usize) -> Option<usize> {
|
|||
Some(width)
|
||||
}
|
||||
|
||||
const EMOJI_RANGES: &'static [Interval] = &[
|
||||
const EMOJI_RANGES: &[Interval] = &[
|
||||
(0x231A, 0x231B), // ; Basic_Emoji ; watch # 1.1 [2] (⌚..⌛)
|
||||
(0x23E9, 0x23EC), // ; Basic_Emoji ; fast-forward button # 6.0 [4] (⏩..⏬)
|
||||
(0x23F0, 0x23F0), // ; Basic_Emoji ; alarm clock # 6.0 [1] (⏰)
|
||||
|
|
|
@ -308,7 +308,7 @@ macro_rules! property {
|
|||
pub fn $name(&self) -> $t {
|
||||
(self.$name).into()
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl Thread {
|
||||
|
@ -842,7 +842,6 @@ impl Threads {
|
|||
|
||||
fn inner_subsort_by(&self, _subsort: (SortField, SortOrder), _envelopes: &Envelopes) {
|
||||
//FIXME: self\.thread_nodes needs interior mutability */
|
||||
return;
|
||||
/*
|
||||
let Threads {
|
||||
ref tree_index,
|
||||
|
|
|
@ -84,7 +84,6 @@ pub mod jobs;
|
|||
pub mod mailcap;
|
||||
pub mod plugins;
|
||||
|
||||
use nix;
|
||||
use std::os::raw::c_int;
|
||||
|
||||
fn notify(
|
||||
|
|
|
@ -220,7 +220,7 @@ impl Composer {
|
|||
id,
|
||||
Box::new(
|
||||
results
|
||||
.into_iter()
|
||||
.iter()
|
||||
.map(|a| a.to_string())
|
||||
.collect::<Vec<String>>()
|
||||
.join(", "),
|
||||
|
@ -244,7 +244,6 @@ impl Composer {
|
|||
);
|
||||
|
||||
drop(parent_message);
|
||||
drop(account);
|
||||
match context.accounts[coordinates.0]
|
||||
.operation(msg)
|
||||
.and_then(|mut op| op.as_bytes())
|
||||
|
@ -262,7 +261,7 @@ impl Composer {
|
|||
.spawn_specialized(fut);
|
||||
context.accounts[coordinates.0]
|
||||
.active_jobs
|
||||
.insert(job_id.clone(), JobRequest::AsBytes);
|
||||
.insert(job_id, JobRequest::AsBytes);
|
||||
if let Ok(Some(parent_bytes)) = try_recv_timeout!(&mut rcvr) {
|
||||
match parent_bytes {
|
||||
Err(err) => {
|
||||
|
|
|
@ -481,8 +481,8 @@ impl ListingTrait for CompactListing {
|
|||
for c in grid.row_iter(x..(self.data_columns.widths[3] + x), get_y(upper_left)) {
|
||||
grid[c].set_bg(bg_color).set_attrs(attrs);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/// Draw the list of `Envelope`s.
|
||||
fn draw_list(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
||||
if self.cursor_pos.1 != self.new_cursor_pos.1 || self.cursor_pos.0 != self.new_cursor_pos.0
|
||||
|
@ -616,8 +616,8 @@ impl ListingTrait for CompactListing {
|
|||
self.data_columns.widths[i] =
|
||||
self.data_columns.segment_tree[i].get_max(top_idx, top_idx + rows) as usize;
|
||||
}
|
||||
if self.data_columns.widths.iter().fold(0, |acc, &w| acc + w) > width {
|
||||
let diff = self.data_columns.widths.iter().fold(0, |acc, &w| acc + w) - width;
|
||||
if self.data_columns.widths.iter().sum::<usize>() > width {
|
||||
let diff = self.data_columns.widths.iter().sum::<usize>() - width;
|
||||
if self.data_columns.widths[2] > 2 * diff {
|
||||
self.data_columns.widths[2] -= diff;
|
||||
} else {
|
||||
|
|
|
@ -515,8 +515,8 @@ impl ListingTrait for ConversationsListing {
|
|||
.set_attrs(attrs);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/// Draw the list of `Envelope`s.
|
||||
fn draw_list(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
||||
if self.cursor_pos.1 != self.new_cursor_pos.1 || self.cursor_pos.0 != self.new_cursor_pos.0
|
||||
|
@ -708,7 +708,7 @@ impl ListingTrait for ConversationsListing {
|
|||
self.length = 0;
|
||||
self.filtered_selection.clear();
|
||||
self.filtered_order.clear();
|
||||
self.filter_term = filter_term.to_string();
|
||||
self.filter_term = filter_term;
|
||||
self.row_updates.clear();
|
||||
for v in self.selection.values_mut() {
|
||||
*v = false;
|
||||
|
@ -1359,7 +1359,7 @@ impl Component for ConversationsListing {
|
|||
.spawn_specialized(job);
|
||||
context.accounts[self.cursor_pos.0]
|
||||
.active_jobs
|
||||
.insert(job_id.clone(), crate::conf::accounts::JobRequest::Search);
|
||||
.insert(job_id, crate::conf::accounts::JobRequest::Search);
|
||||
self.search_job = Some((filter_term.to_string(), chan, job_id));
|
||||
}
|
||||
Err(err) => {
|
||||
|
|
|
@ -91,7 +91,7 @@ impl MailListingTrait for PlainListing {
|
|||
}
|
||||
|
||||
fn get_focused_items(&self, _context: &Context) -> SmallVec<[ThreadHash; 8]> {
|
||||
return SmallVec::new();
|
||||
SmallVec::new()
|
||||
/*
|
||||
let is_selection_empty = self.selection.values().cloned().any(std::convert::identity);
|
||||
if is_selection_empty {
|
||||
|
@ -365,8 +365,8 @@ impl ListingTrait for PlainListing {
|
|||
for c in grid.row_iter(x..(x + self.data_columns.widths[3]), get_y(upper_left)) {
|
||||
grid[c].set_bg(bg_color).set_attrs(attrs);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/// Draw the list of `Envelope`s.
|
||||
fn draw_list(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
|
||||
if self.cursor_pos.1 != self.new_cursor_pos.1 || self.cursor_pos.0 != self.new_cursor_pos.0
|
||||
|
@ -601,7 +601,7 @@ impl ListingTrait for PlainListing {
|
|||
self.length = 0;
|
||||
self.filtered_selection.clear();
|
||||
self.filtered_order.clear();
|
||||
self.filter_term = filter_term.to_string();
|
||||
self.filter_term = filter_term;
|
||||
self.row_updates.clear();
|
||||
for v in self.selection.values_mut() {
|
||||
*v = false;
|
||||
|
|
|
@ -308,7 +308,6 @@ impl MailView {
|
|||
String::new(),
|
||||
Some(NotificationType::ERROR),
|
||||
));
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else if a.is_signed() {
|
||||
|
@ -338,7 +337,7 @@ impl MailView {
|
|||
}
|
||||
ViewMode::Source(Source::Raw) => String::from_utf8_lossy(body.body()).into_owned(),
|
||||
ViewMode::Url => {
|
||||
let mut t = body_text.to_string();
|
||||
let mut t = body_text;
|
||||
for (lidx, l) in finder.links(&body.text()).enumerate() {
|
||||
let offset = if lidx < 10 {
|
||||
lidx * 3
|
||||
|
@ -411,26 +410,20 @@ impl MailView {
|
|||
}
|
||||
} else {
|
||||
match u.content_type() {
|
||||
ContentType::MessageRfc822 => {
|
||||
match EnvelopeWrapper::new(u.body().to_vec()) {
|
||||
Ok(wrapper) => {
|
||||
context.replies.push_back(UIEvent::Action(Tab(New(Some(
|
||||
Box::new(EnvelopeView::new(
|
||||
wrapper,
|
||||
None,
|
||||
None,
|
||||
self.coordinates.0,
|
||||
)),
|
||||
)))));
|
||||
}
|
||||
Err(e) => {
|
||||
context.replies.push_back(UIEvent::StatusEvent(
|
||||
StatusEvent::DisplayMessage(format!("{}", e)),
|
||||
));
|
||||
}
|
||||
ContentType::MessageRfc822 => match EnvelopeWrapper::new(u.body().to_vec()) {
|
||||
Ok(wrapper) => {
|
||||
context
|
||||
.replies
|
||||
.push_back(UIEvent::Action(Tab(New(Some(Box::new(
|
||||
EnvelopeView::new(wrapper, None, None, self.coordinates.0),
|
||||
))))));
|
||||
}
|
||||
return;
|
||||
}
|
||||
Err(e) => {
|
||||
context.replies.push_back(UIEvent::StatusEvent(
|
||||
StatusEvent::DisplayMessage(format!("{}", e)),
|
||||
));
|
||||
}
|
||||
},
|
||||
|
||||
ContentType::Text { .. } | ContentType::PGPSignature => {
|
||||
self.mode = ViewMode::Attachment(lidx);
|
||||
|
@ -443,7 +436,6 @@ impl MailView {
|
|||
"Multipart attachments are not supported yet.".to_string(),
|
||||
),
|
||||
));
|
||||
return;
|
||||
}
|
||||
ContentType::Other { ref name, .. } => {
|
||||
let attachment_type = u.mime_type();
|
||||
|
@ -522,7 +514,6 @@ impl MailView {
|
|||
)
|
||||
}),
|
||||
));
|
||||
return;
|
||||
}
|
||||
}
|
||||
ContentType::OctetStream { ref name } => {
|
||||
|
@ -532,7 +523,6 @@ impl MailView {
|
|||
name.as_ref().map(|n| n.as_str()).unwrap_or("file")
|
||||
)),
|
||||
));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -543,7 +533,6 @@ impl MailView {
|
|||
"Attachment `{}` not found.",
|
||||
lidx
|
||||
))));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -770,11 +759,10 @@ impl Component for MailView {
|
|||
let height = height!(area).saturating_sub(y).saturating_sub(1);
|
||||
if self.pager.cursor_pos() >= self.headers_no {
|
||||
get_y(upper_left)
|
||||
} else if height_p > height && self.headers_cursor < self.headers_no + 1 {
|
||||
y + 1
|
||||
} else if self.headers_cursor == 0 {
|
||||
y + 1
|
||||
} else if height_p < height {
|
||||
} else if (height_p > height && self.headers_cursor < self.headers_no + 1)
|
||||
|| self.headers_cursor == 0
|
||||
|| height_p < height
|
||||
{
|
||||
y + 1
|
||||
} else {
|
||||
get_y(upper_left)
|
||||
|
@ -1226,9 +1214,7 @@ impl Component for MailView {
|
|||
let url = {
|
||||
let finder = LinkFinder::new();
|
||||
let t = match body {
|
||||
Ok(body) => {
|
||||
AttachmentBuilder::new(&body).build().text().to_string()
|
||||
}
|
||||
Ok(body) => AttachmentBuilder::new(&body).build().text(),
|
||||
Err(e) => {
|
||||
context.replies.push_back(UIEvent::Notification(
|
||||
Some("Failed to open e-mail".to_string()),
|
||||
|
@ -1504,7 +1490,6 @@ impl Component for MailView {
|
|||
* on its own */
|
||||
drop(detect);
|
||||
drop(envelope);
|
||||
drop(account);
|
||||
return super::compose::send_draft(
|
||||
ToggleFlag::False,
|
||||
context,
|
||||
|
@ -1696,7 +1681,7 @@ fn attachment_tree(
|
|||
attachment_tree(
|
||||
(idx, (depth + 1, &sub_att_vec[i])),
|
||||
branches,
|
||||
!(iter.peek() == None),
|
||||
iter.peek() != None,
|
||||
s,
|
||||
);
|
||||
}
|
||||
|
|
|
@ -134,7 +134,7 @@ impl EnvelopeView {
|
|||
.into_owned();
|
||||
match self.mode {
|
||||
ViewMode::Normal | ViewMode::Subview => {
|
||||
let mut t = body_text.to_string();
|
||||
let mut t = body_text;
|
||||
if body.count_attachments() > 1 {
|
||||
t = body
|
||||
.attachments()
|
||||
|
@ -149,7 +149,7 @@ impl EnvelopeView {
|
|||
}
|
||||
ViewMode::Raw => String::from_utf8_lossy(body.body()).into_owned(),
|
||||
ViewMode::Url => {
|
||||
let mut t = body_text.to_string();
|
||||
let mut t = body_text;
|
||||
for (lidx, l) in finder.links(&body.text()).enumerate() {
|
||||
let offset = if lidx < 10 {
|
||||
lidx * 3
|
||||
|
@ -521,10 +521,7 @@ impl Component for EnvelopeView {
|
|||
let url = {
|
||||
let envelope: &Envelope = self.wrapper.envelope();
|
||||
let finder = LinkFinder::new();
|
||||
let t = envelope
|
||||
.body_bytes(self.wrapper.buffer())
|
||||
.text()
|
||||
.to_string();
|
||||
let t = envelope.body_bytes(self.wrapper.buffer()).text();
|
||||
let links: Vec<Link> = finder.links(&t).collect();
|
||||
if let Some(u) = links.get(lidx) {
|
||||
u.as_str().to_string()
|
||||
|
|
|
@ -1075,7 +1075,8 @@ impl Component for ThreadView {
|
|||
{
|
||||
let visible_entries: Vec<&usize> =
|
||||
self.visible_entries.iter().flat_map(|v| v.iter()).collect();
|
||||
let search_old_cursor_pos = |entries: Vec<&usize>, x: usize| {
|
||||
/* search_old_cursor_pos */
|
||||
self.new_cursor_pos = (|entries: Vec<&usize>, x: usize| {
|
||||
let mut low = 0;
|
||||
let mut high = entries.len() - 1;
|
||||
while low <= high {
|
||||
|
@ -1089,9 +1090,8 @@ impl Component for ThreadView {
|
|||
high = mid - 1;
|
||||
}
|
||||
}
|
||||
return high + 1; //mid
|
||||
};
|
||||
self.new_cursor_pos = search_old_cursor_pos(visible_entries, self.cursor_pos);
|
||||
high + 1 //mid
|
||||
})(visible_entries, self.cursor_pos);
|
||||
}
|
||||
self.cursor_pos = self.new_cursor_pos;
|
||||
self.recalc_visible_entries();
|
||||
|
|
|
@ -23,7 +23,6 @@
|
|||
Notification handling components.
|
||||
*/
|
||||
use crate::types::RateLimit;
|
||||
use notify_rust;
|
||||
use std::process::{Command, Stdio};
|
||||
|
||||
use super::*;
|
||||
|
|
|
@ -437,9 +437,9 @@ impl Component for SVGScreenshotFilter {
|
|||
fn set_id(&mut self, _id: ComponentId) {}
|
||||
}
|
||||
|
||||
const CSS_STYLE: &'static str = r#"#t{font-family:'DejaVu Sans Mono',monospace;font-style:normal;font-size:14px;} text {dominant-baseline: text-before-edge; white-space: pre;} .f{fill:#e5e5e5;} .b{fill:#000;} .c0 {fill:#000;} .c1 {fill:#cd0000;} .c2 {fill:#00cd00;} .c3 {fill:#cdcd00;} .c4 {fill:#00e;} .c5 {fill:#cd00cd;} .c6 {fill:#00cdcd;} .c7 {fill:#e5e5e5;} .c8 {fill:#7f7f7f;} .c9 {fill:#f00;} .c10 {fill:#0f0;} .c11 {fill:#ff0;} .c12 {fill:#5c5cff;} .c13 {fill:#f0f;} .c14 {fill:#0ff;} .c15 {fill:#fff;}"#;
|
||||
const CSS_STYLE: &str = r#"#t{font-family:'DejaVu Sans Mono',monospace;font-style:normal;font-size:14px;} text {dominant-baseline: text-before-edge; white-space: pre;} .f{fill:#e5e5e5;} .b{fill:#000;} .c0 {fill:#000;} .c1 {fill:#cd0000;} .c2 {fill:#00cd00;} .c3 {fill:#cdcd00;} .c4 {fill:#00e;} .c5 {fill:#cd00cd;} .c6 {fill:#00cdcd;} .c7 {fill:#e5e5e5;} .c8 {fill:#7f7f7f;} .c9 {fill:#f00;} .c10 {fill:#0f0;} .c11 {fill:#ff0;} .c12 {fill:#5c5cff;} .c13 {fill:#f0f;} .c14 {fill:#0ff;} .c15 {fill:#fff;}"#;
|
||||
|
||||
const XTERM_COLORS: &'static [(u8, u8, u8)] = &[
|
||||
const XTERM_COLORS: &[(u8, u8, u8)] = &[
|
||||
/*0*/ (0, 0, 0),
|
||||
/*1*/ (128, 0, 0),
|
||||
/*2*/ (0, 128, 0),
|
||||
|
|
|
@ -86,13 +86,6 @@ impl Field {
|
|||
self.as_str().is_empty()
|
||||
}
|
||||
|
||||
pub fn to_string(&self) -> String {
|
||||
match self {
|
||||
Text(ref s, _) => s.as_str().to_string(),
|
||||
Choice(ref v, ref cursor) => v[*cursor].clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn into_string(self) -> String {
|
||||
match self {
|
||||
Text(s, _) => s.into_string(),
|
||||
|
@ -292,7 +285,14 @@ impl Component for Field {
|
|||
|
||||
impl fmt::Display for Field {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Display::fmt("field", f)
|
||||
write!(
|
||||
f,
|
||||
"{}",
|
||||
match self {
|
||||
Text(ref s, _) => s.as_str().to_string(),
|
||||
Choice(ref v, ref cursor) => v[*cursor].clone(),
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -182,26 +182,26 @@ pub enum JobRequest {
|
|||
impl core::fmt::Debug for JobRequest {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
match self {
|
||||
JobRequest::Mailboxes(_) => write!(f, "{}", "JobRequest::Mailboxes"),
|
||||
JobRequest::Mailboxes(_) => write!(f, "JobRequest::Mailboxes"),
|
||||
JobRequest::Get(hash, _) => write!(f, "JobRequest::Get({})", hash),
|
||||
JobRequest::IsOnline(_) => write!(f, "{}", "JobRequest::IsOnline"),
|
||||
JobRequest::Refresh(_, _) => write!(f, "{}", "JobRequest::Refresh"),
|
||||
JobRequest::SetFlags(_, _) => write!(f, "{}", "JobRequest::SetFlags"),
|
||||
JobRequest::SaveMessage(_, _) => write!(f, "{}", "JobRequest::SaveMessage"),
|
||||
JobRequest::CopyTo(_, _) => write!(f, "{}", "JobRequest::CopyTo"),
|
||||
JobRequest::DeleteMessage(_, _) => write!(f, "{}", "JobRequest::DeleteMessage"),
|
||||
JobRequest::CreateMailbox(_) => write!(f, "{}", "JobRequest::CreateMailbox"),
|
||||
JobRequest::DeleteMailbox(_) => write!(f, "{}", "JobRequest::DeleteMailbox"),
|
||||
JobRequest::IsOnline(_) => write!(f, "JobRequest::IsOnline"),
|
||||
JobRequest::Refresh(_, _) => write!(f, "JobRequest::Refresh"),
|
||||
JobRequest::SetFlags(_, _) => write!(f, "JobRequest::SetFlags"),
|
||||
JobRequest::SaveMessage(_, _) => write!(f, "JobRequest::SaveMessage"),
|
||||
JobRequest::CopyTo(_, _) => write!(f, "JobRequest::CopyTo"),
|
||||
JobRequest::DeleteMessage(_, _) => write!(f, "JobRequest::DeleteMessage"),
|
||||
JobRequest::CreateMailbox(_) => write!(f, "JobRequest::CreateMailbox"),
|
||||
JobRequest::DeleteMailbox(_) => write!(f, "JobRequest::DeleteMailbox"),
|
||||
//JobRequest::RenameMailbox,
|
||||
JobRequest::Search => write!(f, "{}", "JobRequest::Search"),
|
||||
JobRequest::AsBytes => write!(f, "{}", "JobRequest::AsBytes"),
|
||||
JobRequest::Search => write!(f, "JobRequest::Search"),
|
||||
JobRequest::AsBytes => write!(f, "JobRequest::AsBytes"),
|
||||
JobRequest::SetMailboxPermissions(_, _) => {
|
||||
write!(f, "{}", "JobRequest::SetMailboxPermissions")
|
||||
write!(f, "JobRequest::SetMailboxPermissions")
|
||||
}
|
||||
JobRequest::SetMailboxSubscription(_, _) => {
|
||||
write!(f, "{}", "JobRequest::SetMailboxSubscription")
|
||||
write!(f, "JobRequest::SetMailboxSubscription")
|
||||
}
|
||||
JobRequest::Watch(_) => write!(f, "{}", "JobRequest::Watch"),
|
||||
JobRequest::Watch(_) => write!(f, "JobRequest::Watch"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -501,7 +501,7 @@ impl Account {
|
|||
let (rcvr, job_id) = self.job_executor.spawn_specialized(mailbox_job);
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::NewJob(job_id.clone()),
|
||||
StatusEvent::NewJob(job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
self.active_jobs.insert(job_id, JobRequest::Get(*h, rcvr));
|
||||
|
@ -836,7 +836,7 @@ impl Account {
|
|||
let (rcvr, job_id) = self.job_executor.spawn_specialized(refresh_job);
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::NewJob(job_id.clone()),
|
||||
StatusEvent::NewJob(job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
self.active_jobs
|
||||
|
@ -959,7 +959,7 @@ impl Account {
|
|||
self.job_executor.spawn_specialized(mailbox_job);
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::NewJob(job_id.clone()),
|
||||
StatusEvent::NewJob(job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
self.active_jobs.insert(
|
||||
|
@ -1150,7 +1150,7 @@ impl Account {
|
|||
let (rcvr, job_id) = self.job_executor.spawn_specialized(job);
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::NewJob(job_id.clone()),
|
||||
StatusEvent::NewJob(job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
self.active_jobs
|
||||
|
@ -1465,7 +1465,7 @@ impl Account {
|
|||
JobRequest::Get(mailbox_hash, mut chan) => {
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::JobFinished(job_id.clone()),
|
||||
StatusEvent::JobFinished(*job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
|
||||
|
@ -1491,7 +1491,7 @@ impl Account {
|
|||
let (rcvr, job_id) = self.job_executor.spawn_specialized(rest.into_future());
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::NewJob(job_id.clone()),
|
||||
StatusEvent::NewJob(job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
self.active_jobs
|
||||
|
@ -1561,7 +1561,7 @@ impl Account {
|
|||
}
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::JobFinished(job_id.clone()),
|
||||
StatusEvent::JobFinished(*job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
}
|
||||
|
@ -1664,7 +1664,7 @@ impl Account {
|
|||
JobRequest::Search | JobRequest::AsBytes => {
|
||||
self.sender
|
||||
.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
|
||||
StatusEvent::JobFinished(job_id.clone()),
|
||||
StatusEvent::JobFinished(*job_id),
|
||||
)))
|
||||
.unwrap();
|
||||
}
|
||||
|
|
|
@ -241,7 +241,7 @@ fn unlink_attrs<'k, 't: 'k>(theme: &'t Theme, mut key: &'k Cow<'static, str>) ->
|
|||
}
|
||||
}
|
||||
|
||||
const DEFAULT_KEYS: &'static [&'static str] = &[
|
||||
const DEFAULT_KEYS: &[&str] = &[
|
||||
"theme_default",
|
||||
"status.bar",
|
||||
"status.notification",
|
||||
|
@ -504,7 +504,7 @@ mod regexp {
|
|||
use super::*;
|
||||
use crate::terminal::FormatTag;
|
||||
|
||||
pub(super) const DEFAULT_TEXT_FORMATTER_KEYS: &'static [&'static str] =
|
||||
pub(super) const DEFAULT_TEXT_FORMATTER_KEYS: &[&str] =
|
||||
&["pager.envelope.body", "listing.from", "listing.subject"];
|
||||
|
||||
#[derive(Clone)]
|
||||
|
@ -1582,7 +1582,7 @@ impl Default for Themes {
|
|||
add!("mail.view.thread.indentation.c", light = { bg: Color::Byte(175) }, dark = { bg: Color::Byte(175) }); // Pink3
|
||||
add!("mail.view.thread.indentation.d", light = { bg: Color::Byte(220) }, dark = { bg: Color::Byte(220) }); // Gold1
|
||||
add!("mail.view.thread.indentation.e", light = { bg: Color::Byte(172) }, dark = { bg: Color::Byte(172) }); // Orange3
|
||||
add!("mail.view.thread.indentation.f", light = { bg: Color::Byte(072) }, dark = { bg: Color::Byte(072) }); // CadetBlue
|
||||
add!("mail.view.thread.indentation.f", light = { bg: Color::Byte(72) }, dark = { bg: Color::Byte(72) }); // CadetBlue
|
||||
|
||||
add!(
|
||||
"mail.listing.attachment_flag",
|
||||
|
@ -1727,29 +1727,27 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
ThemeValue::Link(ref l, ColorField::LikeSelf)
|
||||
| ThemeValue::Link(ref l, ColorField::Fg) => {
|
||||
path.push((l, Course::Fg));
|
||||
if !visited[&(l, Course::Fg)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, Course::Fg)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme))
|
||||
|| stack[&(l, Course::Fg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, Course::Fg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Link(ref l, ColorField::Bg) => {
|
||||
path.push((l, Course::Bg));
|
||||
if !visited[&(l, Course::Bg)]
|
||||
&& is_cyclic_util(Course::Bg, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, Course::Bg)]
|
||||
&& is_cyclic_util(Course::Bg, l, visited, stack, path, theme))
|
||||
|| stack[&(l, Course::Bg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, Course::Bg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Alias(ref ident) => {
|
||||
path.push((ident, Course::ColorAliasFg));
|
||||
if !visited[&(ident, Course::ColorAliasFg)]
|
||||
if (!visited[&(ident, Course::ColorAliasFg)]
|
||||
&& is_cyclic_util(
|
||||
Course::ColorAliasFg,
|
||||
ident,
|
||||
|
@ -1757,11 +1755,10 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
stack,
|
||||
path,
|
||||
theme,
|
||||
)
|
||||
))
|
||||
|| stack[&(ident, Course::ColorAliasFg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(ident, Course::ColorAliasFg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
|
@ -1771,29 +1768,27 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
ThemeValue::Link(ref l, ColorField::LikeSelf)
|
||||
| ThemeValue::Link(ref l, ColorField::Bg) => {
|
||||
path.push((l, Course::Bg));
|
||||
if !visited[&(l, Course::Bg)]
|
||||
&& is_cyclic_util(Course::Bg, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, Course::Bg)]
|
||||
&& is_cyclic_util(Course::Bg, l, visited, stack, path, theme))
|
||||
|| stack[&(l, Course::Bg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, Course::Bg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Link(ref l, ColorField::Fg) => {
|
||||
path.push((l, Course::Fg));
|
||||
if !visited[&(l, Course::Fg)]
|
||||
&& is_cyclic_util(Course::Fg, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, Course::Fg)]
|
||||
&& is_cyclic_util(Course::Fg, l, visited, stack, path, theme))
|
||||
|| stack[&(l, Course::Fg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, Course::Fg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Alias(ref ident) => {
|
||||
path.push((ident, Course::ColorAliasBg));
|
||||
if !visited[&(ident, Course::ColorAliasBg)]
|
||||
if (!visited[&(ident, Course::ColorAliasBg)]
|
||||
&& is_cyclic_util(
|
||||
Course::ColorAliasBg,
|
||||
ident,
|
||||
|
@ -1801,11 +1796,10 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
stack,
|
||||
path,
|
||||
theme,
|
||||
)
|
||||
))
|
||||
|| stack[&(ident, Course::ColorAliasBg)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(ident, Course::ColorAliasBg)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
|
@ -1814,23 +1808,28 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
Course::Attrs => match theme[k].attrs {
|
||||
ThemeValue::Link(ref l, _) => {
|
||||
path.push((l, course));
|
||||
if !visited[&(l, course)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, course)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme))
|
||||
|| stack[&(l, course)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, course)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Alias(ref ident) => {
|
||||
path.push((ident, Course::AttrAlias));
|
||||
if !visited[&(ident, Course::AttrAlias)]
|
||||
&& is_cyclic_util(Course::AttrAlias, ident, visited, stack, path, theme)
|
||||
if (!visited[&(ident, Course::AttrAlias)]
|
||||
&& is_cyclic_util(
|
||||
Course::AttrAlias,
|
||||
ident,
|
||||
visited,
|
||||
stack,
|
||||
path,
|
||||
theme,
|
||||
))
|
||||
|| stack[&(ident, Course::AttrAlias)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(ident, Course::AttrAlias)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
|
@ -1848,23 +1847,21 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
(_, ColorField::Bg) => Course::Bg,
|
||||
};
|
||||
path.push((l, course));
|
||||
if !visited[&(l, course)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, course)]
|
||||
&& is_cyclic_util(course, l, visited, stack, path, theme))
|
||||
|| stack[&(l, course)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, course)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Alias(ref ident) => {
|
||||
path.push((ident, course));
|
||||
if !visited[&(ident, course)]
|
||||
&& is_cyclic_util(course, ident, visited, stack, path, theme)
|
||||
if (!visited[&(ident, course)]
|
||||
&& is_cyclic_util(course, ident, visited, stack, path, theme))
|
||||
|| stack[&(ident, course)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(ident, course)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
|
@ -1873,23 +1870,21 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
Course::AttrAlias => match &theme.attr_aliases[k] {
|
||||
ThemeValue::Link(ref l, ()) => {
|
||||
path.push((l, Course::Attrs));
|
||||
if !visited[&(l, Course::Attrs)]
|
||||
&& is_cyclic_util(Course::Attrs, l, visited, stack, path, theme)
|
||||
if (!visited[&(l, Course::Attrs)]
|
||||
&& is_cyclic_util(Course::Attrs, l, visited, stack, path, theme))
|
||||
|| stack[&(l, Course::Attrs)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(l, Course::Attrs)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
ThemeValue::Alias(ref ident) => {
|
||||
path.push((ident, course));
|
||||
if !visited[&(ident, course)]
|
||||
&& is_cyclic_util(course, ident, visited, stack, path, theme)
|
||||
if (!visited[&(ident, course)]
|
||||
&& is_cyclic_util(course, ident, visited, stack, path, theme))
|
||||
|| stack[&(ident, course)]
|
||||
{
|
||||
return true;
|
||||
} else if stack[&(ident, course)] {
|
||||
return true;
|
||||
}
|
||||
path.pop();
|
||||
}
|
||||
|
@ -1898,7 +1893,7 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
|
|||
}
|
||||
}
|
||||
stack.entry((k, course)).and_modify(|e| *e = false);
|
||||
return false;
|
||||
false
|
||||
}
|
||||
|
||||
let mut path = SmallVec::new();
|
||||
|
@ -1973,7 +1968,7 @@ fn test_theme_parsing() {
|
|||
let def = Themes::default();
|
||||
assert!(def.validate().is_ok());
|
||||
/* MUST SUCCEED: new user theme `hunter2`, theme `dark` has user redefinitions */
|
||||
const TEST_STR: &'static str = r##"[dark]
|
||||
const TEST_STR: &str = r##"[dark]
|
||||
"mail.listing.tag_default" = { fg = "White", bg = "HotPink3" }
|
||||
"mail.listing.attachment_flag" = { fg = "mail.listing.tag_default.bg" }
|
||||
"mail.view.headers" = { bg = "mail.listing.tag_default.fg" }
|
||||
|
@ -2008,20 +2003,20 @@ fn test_theme_parsing() {
|
|||
);
|
||||
assert!(parsed.validate().is_ok());
|
||||
/* MUST FAIL: theme `dark` contains a cycle */
|
||||
const HAS_CYCLE: &'static str = r##"[dark]
|
||||
const HAS_CYCLE: &str = r##"[dark]
|
||||
"mail.listing.compact.even" = { fg = "mail.listing.compact.odd" }
|
||||
"mail.listing.compact.odd" = { fg = "mail.listing.compact.even" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(HAS_CYCLE).unwrap();
|
||||
assert!(parsed.validate().is_err());
|
||||
/* MUST FAIL: theme `dark` contains an invalid key */
|
||||
const HAS_INVALID_KEYS: &'static str = r##"[dark]
|
||||
const HAS_INVALID_KEYS: &str = r##"[dark]
|
||||
"asdfsafsa" = { fg = "Black" }
|
||||
"##;
|
||||
let parsed: std::result::Result<Themes, _> = toml::from_str(HAS_INVALID_KEYS);
|
||||
assert!(parsed.is_err());
|
||||
/* MUST SUCCEED: alias $Jebediah resolves to a valid color */
|
||||
const TEST_ALIAS_STR: &'static str = r##"[dark]
|
||||
const TEST_ALIAS_STR: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "#b4da55" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebediah" }
|
||||
"##;
|
||||
|
@ -2036,42 +2031,42 @@ color_aliases= { "Jebediah" = "#b4da55" }
|
|||
Color::Rgb(180, 218, 85)
|
||||
);
|
||||
/* MUST FAIL: Mispell color alias $Jebediah as $Jebedia */
|
||||
const TEST_INVALID_ALIAS_STR: &'static str = r##"[dark]
|
||||
const TEST_INVALID_ALIAS_STR: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "#b4da55" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebedia" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(TEST_INVALID_ALIAS_STR).unwrap();
|
||||
assert!(parsed.validate().is_err());
|
||||
/* MUST FAIL: Color alias $Jebediah is defined as itself */
|
||||
const TEST_CYCLIC_ALIAS_STR: &'static str = r##"[dark]
|
||||
const TEST_CYCLIC_ALIAS_STR: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "$Jebediah" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebediah" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR).unwrap();
|
||||
assert!(parsed.validate().is_err());
|
||||
/* MUST FAIL: Attr alias $Jebediah is defined as itself */
|
||||
const TEST_CYCLIC_ALIAS_ATTR_STR: &'static str = r##"[dark]
|
||||
const TEST_CYCLIC_ALIAS_ATTR_STR: &str = r##"[dark]
|
||||
attr_aliases= { "Jebediah" = "$Jebediah" }
|
||||
"mail.listing.tag_default" = { attrs = "$Jebediah" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_ATTR_STR).unwrap();
|
||||
assert!(parsed.validate().is_err());
|
||||
/* MUST FAIL: alias $Jebediah resolves to a cycle */
|
||||
const TEST_CYCLIC_ALIAS_STR_2: &'static str = r##"[dark]
|
||||
const TEST_CYCLIC_ALIAS_STR_2: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebediah" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_2).unwrap();
|
||||
assert!(parsed.validate().is_err());
|
||||
/* MUST SUCCEED: alias $Jebediah resolves to a key's field */
|
||||
const TEST_CYCLIC_ALIAS_STR_3: &'static str = r##"[dark]
|
||||
const TEST_CYCLIC_ALIAS_STR_3: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.bg" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
|
||||
"##;
|
||||
let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_3).unwrap();
|
||||
assert!(parsed.validate().is_ok());
|
||||
/* MUST FAIL: alias $Jebediah resolves to an invalid key */
|
||||
const TEST_INVALID_LINK_KEY_FIELD_STR: &'static str = r##"[dark]
|
||||
const TEST_INVALID_LINK_KEY_FIELD_STR: &str = r##"[dark]
|
||||
color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.attrs" }
|
||||
"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
|
||||
"##;
|
||||
|
|
|
@ -34,7 +34,6 @@ use melib::nom::{
|
|||
};
|
||||
pub use melib::thread::{SortField, SortOrder};
|
||||
use melib::MeliError;
|
||||
use std;
|
||||
pub mod actions;
|
||||
use actions::MailboxOperation;
|
||||
use std::collections::HashSet;
|
||||
|
@ -776,11 +775,7 @@ pub fn command_completion_suggestions(input: &str) -> Vec<String> {
|
|||
}
|
||||
if let Some((s, Filepath)) = _m.last() {
|
||||
let p = std::path::Path::new(s);
|
||||
sugg.extend(
|
||||
p.complete(true)
|
||||
.into_iter()
|
||||
.map(|m| m.into()),
|
||||
);
|
||||
sugg.extend(p.complete(true).into_iter().map(|m| m.into()));
|
||||
}
|
||||
}
|
||||
sugg.into_iter()
|
||||
|
|
|
@ -40,8 +40,8 @@ use std::convert::TryInto;
|
|||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
const DB_NAME: &'static str = "index.db";
|
||||
const INIT_SCRIPT: &'static str = "CREATE TABLE IF NOT EXISTS envelopes (
|
||||
const DB_NAME: &str = "index.db";
|
||||
const INIT_SCRIPT: &str = "CREATE TABLE IF NOT EXISTS envelopes (
|
||||
id INTEGER PRIMARY KEY,
|
||||
account_id INTEGER REFERENCES accounts ON UPDATE CASCADE,
|
||||
hash BLOB NOT NULL UNIQUE,
|
||||
|
|
|
@ -679,7 +679,7 @@ impl State {
|
|||
},
|
||||
),
|
||||
);
|
||||
copy_area(&mut self.overlay_grid, &mut self.grid, area, area);
|
||||
copy_area(&mut self.overlay_grid, &self.grid, area, area);
|
||||
self.overlay
|
||||
.get_mut(0)
|
||||
.unwrap()
|
||||
|
|
|
@ -233,7 +233,7 @@ mod braille {
|
|||
for b in iter {
|
||||
print!("{}", b);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
}
|
||||
|
||||
println!("fbird: ");
|
||||
|
@ -242,7 +242,7 @@ mod braille {
|
|||
for b in iter {
|
||||
print!("{}", b);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
}
|
||||
println!("ABC QR code: ");
|
||||
for lines in _X_QRCODE.chunks(12) {
|
||||
|
@ -250,7 +250,7 @@ mod braille {
|
|||
for b in iter {
|
||||
print!("{}", b);
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -283,7 +283,7 @@ impl CellBuffer {
|
|||
} else {
|
||||
scroll_region.right
|
||||
};
|
||||
for y in top..=(top + offset - 1) {
|
||||
for y in top..top + offset {
|
||||
for x in l..r {
|
||||
self[(x, y)] = Cell::default();
|
||||
}
|
||||
|
@ -1103,7 +1103,7 @@ impl Color {
|
|||
_ => u8::from_str_radix(&s, 10)
|
||||
.map_err(|_| de::Error::custom("invalid `color` value"))?,
|
||||
};
|
||||
return Ok(Color::Byte(byte));
|
||||
Ok(Color::Byte(byte))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2795,7 +2795,7 @@ fn test_cellbuffer_search() {
|
|||
for c in &buf.cellvec()[ind..std::cmp::min(buf.cellvec().len(), ind + 25)] {
|
||||
print!("{}", c.ch());
|
||||
}
|
||||
println!("");
|
||||
println!();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -163,7 +163,7 @@ pub fn get_events(
|
|||
mut closure: impl FnMut((Key, Vec<u8>)),
|
||||
rx: &Receiver<InputCommand>,
|
||||
new_command_fd: RawFd,
|
||||
) -> () {
|
||||
) {
|
||||
let stdin = std::io::stdin();
|
||||
let stdin_fd = PollFd::new(std::io::stdin().as_raw_fd(), PollFlags::POLLIN);
|
||||
let new_command_pollfd = nix::poll::PollFd::new(new_command_fd, nix::poll::PollFlags::POLLIN);
|
||||
|
|
|
@ -42,7 +42,6 @@ use super::terminal::*;
|
|||
use melib::backends::{AccountHash, MailboxHash};
|
||||
use melib::{EnvelopeHash, RefreshEvent, ThreadHash};
|
||||
use nix::unistd::Pid;
|
||||
use std;
|
||||
use std::fmt;
|
||||
use std::thread;
|
||||
use uuid::Uuid;
|
||||
|
|
|
@ -19,7 +19,6 @@
|
|||
* along with meli. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
use std;
|
||||
use std::fs;
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::{Read, Write};
|
||||
|
|
Loading…
Reference in New Issue