apply cr

Author: dignifiedquire

src/accounts.rs

@@ -101,7 +101,7 @@ impl Accounts {
         let account_config = self.config.new_account(&self.dir).await?;
 
         let ctx = Context::new(
-            account_config.dbfile(),
+            &account_config.dbfile(),
             account_config.id,
             self.events.clone(),
         )
@@ -116,7 +116,7 @@ impl Accounts {
         let account_config = self.config.new_account(&self.dir).await?;
 
         let ctx = Context::new_closed(
-            account_config.dbfile(),
+            &account_config.dbfile(),
             account_config.id,
             self.events.clone(),
         )
@@ -204,7 +204,7 @@ impl Accounts {
 
         match res {
             Ok(_) => {
-                let ctx = Context::new(new_dbfile, account_config.id, self.events.clone()).await?;
+                let ctx = Context::new(&new_dbfile, account_config.id, self.events.clone()).await?;
                 self.accounts.insert(account_config.id, ctx);
                 Ok(account_config.id)
             }
@@ -342,7 +342,7 @@ impl Config {
     pub async fn load_accounts(&self, events: &Events) -> Result<BTreeMap<u32, Context>> {
         let mut accounts = BTreeMap::new();
         for account_config in &self.inner.accounts {
-            let ctx = Context::new(account_config.dbfile(), account_config.id, events.clone())
+            let ctx = Context::new(&account_config.dbfile(), account_config.id, events.clone())
                 .await
                 .with_context(|| {
                     format!(
@@ -523,7 +523,7 @@ mod tests {
         assert_eq!(accounts.config.get_selected_account().await, 0);
 
         let extern_dbfile: PathBuf = dir.path().join("other");
-        let ctx = Context::new(extern_dbfile.clone(), 0, Events::new())
+        let ctx = Context::new(&extern_dbfile, 0, Events::new())
             .await
             .unwrap();
         ctx.set_config(crate::config::Config::Addr, Some("[email protected]"))

src/context.rs

@@ -114,7 +114,7 @@ pub fn get_info() -> BTreeMap<&'static str, String> {
 
 impl Context {
     /// Creates new context and opens the database.
-    pub async fn new<P: AsRef<Path>>(dbfile: P, id: u32, events: Events) -> Result<Context> {
+    pub async fn new(dbfile: &Path, id: u32, events: Events) -> Result<Context> {
         let context = Self::new_closed(dbfile, id, events).await?;
 
         // Open the database if is not encrypted.
@@ -125,9 +125,8 @@ impl Context {
     }
 
     /// Creates new context without opening the database.
-    pub async fn new_closed<P: AsRef<Path>>(dbfile: P, id: u32, events: Events) -> Result<Context> {
+    pub async fn new_closed(dbfile: &Path, id: u32, events: Events) -> Result<Context> {
         let mut blob_fname = OsString::new();
-        let dbfile = dbfile.as_ref();
         blob_fname.push(dbfile.file_name().unwrap_or_default());
         blob_fname.push("-blobs");
         let blobdir = dbfile.with_file_name(blob_fname);
@@ -684,7 +683,7 @@ mod tests {
         let tmp = tempfile::tempdir()?;
         let dbfile = tmp.path().join("db.sqlite");
         std::fs::write(&dbfile, b"123")?;
-        let res = Context::new(dbfile, 1, Events::new()).await?;
+        let res = Context::new(&dbfile, 1, Events::new()).await?;
 
         // Broken database is indistinguishable from encrypted one.
         assert_eq!(res.is_open().await, false);
@@ -830,7 +829,7 @@ mod tests {
     async fn test_blobdir_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
-        Context::new(dbfile, 1, Events::new()).await.unwrap();
+        Context::new(&dbfile, 1, Events::new()).await.unwrap();
         let blobdir = tmp.path().join("db.sqlite-blobs");
         assert!(blobdir.is_dir());
     }
@@ -841,7 +840,7 @@ mod tests {
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = tmp.path().join("db.sqlite-blobs");
         std::fs::write(&blobdir, b"123").unwrap();
-        let res = Context::new(dbfile, 1, Events::new()).await;
+        let res = Context::new(&dbfile, 1, Events::new()).await;
         assert!(res.is_err());
     }
 
@@ -851,7 +850,7 @@ mod tests {
         let subdir = tmp.path().join("subdir");
         let dbfile = subdir.join("db.sqlite");
         let dbfile2 = dbfile.clone();
-        Context::new(dbfile, 1, Events::new()).await.unwrap();
+        Context::new(&dbfile, 1, Events::new()).await.unwrap();
         assert!(subdir.is_dir());
         assert!(dbfile2.is_file());
     }

src/dc_tools.rs

@@ -277,7 +277,7 @@ pub fn dc_get_filemeta(buf: &[u8]) -> Result<(u32, u32), Error> {
 ///
 /// If `path` starts with "$BLOBDIR", replaces it with the blobdir path.
 /// Otherwise, returns path as is.
-pub(crate) fn dc_get_abs_path<P: AsRef<Path>>(context: &Context, path: P) -> PathBuf {
+pub(crate) fn dc_get_abs_path(context: &Context, path: impl AsRef<Path>) -> PathBuf {
     let p: &Path = path.as_ref();
     if let Ok(p) = p.strip_prefix("$BLOBDIR") {
         context.get_blobdir().join(p)

src/key.rs

@@ -222,8 +222,8 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
             info!(context, "Generating keypair with type {}", keytype);
             let keypair = Handle::current()
                 .spawn_blocking(move || crate::pgp::create_keypair(addr, keytype))
-                .await
-                .unwrap()?;
+                .await??;
+
             store_self_keypair(context, &keypair, KeyPairUse::Default).await?;
             info!(
                 context,

src/pgp.rs

@@ -251,8 +251,7 @@ pub async fn pk_encrypt(
 
             Ok(encoded_msg)
         })
-        .await
-        .unwrap()
+        .await?
 }
 
 /// Decrypts the message with keys from the private key keyring.
@@ -280,8 +279,7 @@ pub async fn pk_decrypt(
         let (decryptor, _) = msg.decrypt(|| "".into(), || "".into(), &skeys[..])?;
         decryptor.collect::<pgp::errors::Result<Vec<_>>>()
     })
-    .await
-    .unwrap()?;
+    .await??;
 
     if let Some(msg) = msgs.into_iter().next() {
         // get_content() will decompress the message if needed,
@@ -356,8 +354,7 @@ pub async fn symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String> {
 
         Ok(encoded_msg)
     })
-    .await
-    .unwrap()
+    .await?
 }
 
 /// Symmetric decryption.
@@ -381,8 +378,7 @@ pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
             bail!("No valid messages found")
         }
     })
-    .await
-    .unwrap()
+    .await?
 }
 
 #[cfg(test)]

src/provider.rs

@@ -85,9 +85,9 @@ pub struct Provider {
 
 /// Get resolver to query MX records.
 ///
-/// We first try resolver_from_system_conf() which reads the system's resolver from `/etc/resolv.conf`.
-/// This does not work at least on some Androids, therefore we use use ResolverConfig::default()
-/// which default eg. to google's 8.8.8.8 or 8.8.4.4 as a fallback.
+/// We first try reads the system's resolver from `/etc/resolv.conf`.
+/// This does not work at least on some Androids, therefore we fallback
+/// to the default `ResolverConfig` which uses eg. to google's `8.8.8.8` or `8.8.4.4`.
 fn get_resolver() -> Result<TokioAsyncResolver> {
     if let Ok(resolver) = AsyncResolver::tokio_from_system_conf() {
         return Ok(resolver);

src/test_utils.rs

@@ -277,7 +277,7 @@ impl TestContext {
             let mut context_names = CONTEXT_NAMES.write().unwrap();
             context_names.insert(id, name);
         }
-        let ctx = Context::new(dbfile, id, Events::new())
+        let ctx = Context::new(&dbfile, id, Events::new())
             .await
             .expect("failed to create context");