meli
/
meli
8
Fork 13
Code Issues 10 Pull Requests 10 Actions Packages Projects 1 Releases 18 Wiki Activity

melib: remove unused BackendOp::fetch_flags() method

pull/260/head
Manos Pitsidianakis 2023-07-18 15:51:31 +03:00
parent 0219dc8707
commit 48a10f7241
Signed by: Manos Pitsidianakis
GPG Key ID: 7729C7707F7E09D0
8 changed files with 2 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
meli/src/plugins/backend.rs
View File

@ -298,8 +298,4 @@ impl BackendOp for PluginOp {
}
}))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
Err(Error::new("Unimplemented."))
}
}

7
melib/src/backends.rs
View File

@ -475,16 +475,12 @@ pub trait MailBackend: ::std::fmt::Debug + Send + Sync {
/// fn as_bytes(&mut self) -> Result<&[u8]> {
/// unimplemented!()
/// }
/// fn fetch_flags(&self) -> Result<Flag> {
/// unimplemented!()
/// }
/// }
///
/// let operation = Box::new(FooOp {});
/// ```
pub trait BackendOp: ::std::fmt::Debug + ::std::marker::Send {
fn as_bytes(&mut self) -> ResultFuture<Vec<u8>>;
fn fetch_flags(&self) -> ResultFuture<Flag>;
}
/// Wrapper for BackendOps that are to be set read-only.
@ -507,9 +503,6 @@ impl BackendOp for ReadOnlyOp {
fn as_bytes(&mut self) -> ResultFuture<Vec<u8>> {
self.op.as_bytes()
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
self.op.fetch_flags()
}
}
#[derive(Default, Debug, Copy, Hash, Eq, Clone, Serialize, Deserialize, PartialEq)]

63
melib/src/backends/imap/operations.rs
View File

@ -24,7 +24,7 @@ use std::sync::Arc;
use imap_codec::fetch::MessageDataItemName;
use super::*;
use crate::{backends::*, email::*, error::Error};
use crate::{backends::*, error::Error};
/// `BackendOp` implementor for Imap
#[derive(Debug, Clone)]
@ -114,65 +114,4 @@ impl BackendOp for ImapOp {
Ok(ret)
}))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
let mut response = Vec::with_capacity(8 * 1024);
let connection = self.connection.clone();
let mailbox_hash = self.mailbox_hash;
let uid = self.uid;
let uid_store = self.uid_store.clone();
Ok(Box::pin(async move {
let exists_in_cache = {
let mut bytes_cache = uid_store.byte_cache.lock()?;
let cache = bytes_cache.entry(uid).or_default();
cache.flags.is_some()
};
if !exists_in_cache {
let mut conn = connection.lock().await;
conn.connect().await?;
conn.examine_mailbox(mailbox_hash, &mut response, false)
.await?;
conn.send_command(CommandBody::fetch(
uid,
vec![MessageDataItemName::Flags],
true,
)?)
.await?;
conn.read_response(&mut response, RequiredResponses::FETCH_REQUIRED)
.await?;
debug!(
"fetch response is {} bytes and {} lines",
response.len(),
String::from_utf8_lossy(&response).lines().count()
);
let v = protocol_parser::uid_fetch_flags_responses(&response)
.map(|(_, v)| v)
.map_err(Error::from)?;
if v.len() != 1 {
debug!("responses len is {}", v.len());
debug!(String::from_utf8_lossy(&response));
/* [ref:TODO]: Trigger cache invalidation here. */
debug!("message with UID {} was not found", uid);
return Err(
Error::new(format!("Invalid/unexpected response: {:?}", response))
.set_summary(format!("message with UID {} was not found?", uid)),
);
}
let (_uid, (_flags, _)) = v[0];
assert_eq!(_uid, uid);
let mut bytes_cache = uid_store.byte_cache.lock()?;
let cache = bytes_cache.entry(uid).or_default();
cache.flags = Some(_flags);
}
{
let val = {
let mut bytes_cache = uid_store.byte_cache.lock()?;
let cache = bytes_cache.entry(uid).or_default();
cache.flags
};
Ok(val.unwrap())
}
}))
}
}

4
melib/src/backends/jmap/operations.rs
View File

@ -84,8 +84,4 @@ impl BackendOp for JmapOp {
Ok(res_text.into_bytes())
}))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
Ok(Box::pin(async { Ok(Flag::default()) }))
}
}

6
melib/src/backends/maildir.rs
View File

@ -110,12 +110,6 @@ impl BackendOp for MaildirOp {
let ret = Ok(self.slice.as_ref().unwrap().as_slice().to_vec());
Ok(Box::pin(async move { ret }))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
let path = self.path()?;
let ret = Ok(path.flags());
Ok(Box::pin(async move { ret }))
}
}
#[derive(Debug, Default, Clone)]

60
melib/src/backends/mbox.rs
View File

@ -322,66 +322,6 @@ impl BackendOp for MboxOp {
.to_vec();
Ok(Box::pin(async move { Ok(ret) }))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
let mut flags = Flag::empty();
if self.slice.borrow().is_none() {
let file = std::fs::OpenOptions::new()
.read(true)
.write(true)
.open(&self.path)?;
get_rw_lock_blocking(&file, &self.path)?;
let mut buf_reader = BufReader::new(file);
let mut contents = Vec::new();
buf_reader.read_to_end(&mut contents)?;
*self.slice.borrow_mut() = Some(contents);
}
let slice_ref = self.slice.borrow();
let (_, headers) = parser::headers::headers_raw(slice_ref.as_ref().unwrap().as_slice())?;
if let Some(start) = headers.find(b"Status:") {
if let Some(end) = headers[start..].find(b"\n") {
let start = start + b"Status:".len();
let status = headers[start..start + end].trim();
if status.contains(&b'F') {
flags.set(Flag::FLAGGED, true);
}
if status.contains(&b'A') {
flags.set(Flag::REPLIED, true);
}
if status.contains(&b'R') {
flags.set(Flag::SEEN, true);
}
if status.contains(&b'D') {
flags.set(Flag::TRASHED, true);
}
if status.contains(&b'T') {
flags.set(Flag::DRAFT, true);
}
}
}
if let Some(start) = headers.find(b"X-Status:") {
let start = start + b"X-Status:".len();
if let Some(end) = headers[start..].find(b"\n") {
let status = headers[start..start + end].trim();
if status.contains(&b'F') {
flags.set(Flag::FLAGGED, true);
}
if status.contains(&b'A') {
flags.set(Flag::REPLIED, true);
}
if status.contains(&b'R') {
flags.set(Flag::SEEN, true);
}
if status.contains(&b'D') {
flags.set(Flag::TRASHED, true);
}
if status.contains(&b'T') {
flags.set(Flag::DRAFT, true);
}
}
}
Ok(Box::pin(async move { Ok(flags) }))
}
}
#[derive(Debug, Clone, Copy)]

6
melib/src/backends/nntp/operations.rs
View File

@ -22,7 +22,7 @@
use std::sync::Arc;
use super::*;
use crate::{backends::*, email::*, error::Error};
use crate::{backends::*, error::Error};
/// `BackendOp` implementor for Nntp
#[derive(Debug, Clone)]
@ -84,8 +84,4 @@ impl BackendOp for NntpOp {
Ok(res.as_bytes()[pos..].to_vec())
}))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
Ok(Box::pin(async move { Ok(Flag::default()) }))
}
}

7
melib/src/backends/notmuch.rs
View File

@ -1059,13 +1059,6 @@ impl BackendOp for NotmuchOp {
let ret = Ok(self.bytes.as_ref().unwrap().to_vec());
Ok(Box::pin(async move { ret }))
}
fn fetch_flags(&self) -> ResultFuture<Flag> {
let index_lck = self.index.write().unwrap();
let message = Message::find_message(&self.database, &index_lck[&self.hash])?;
let (flags, _tags) = message.tags().collect_flags_and_tags();
Ok(Box::pin(async move { Ok(flags) }))
}
}
pub struct Query<'s> {