improve backend features management for every command

src/folder/command/create.rs

@@ -1,10 +1,18 @@
 use anyhow::Result;
 use clap::Parser;
+#[cfg(feature = "imap")]
+use email::folder::add::imap::AddFolderImap;
+#[cfg(feature = "maildir")]
+use email::folder::add::maildir::AddFolderMaildir;
 use log::info;
 
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, cache::arg::disable::CacheDisableFlag,
-    config::TomlConfig, folder::arg::name::FolderNameArg, printer::Printer,
+    account::arg::name::AccountNameFlag,
+    backend::{Backend, BackendKind},
+    cache::arg::disable::CacheDisableFlag,
+    config::TomlConfig,
+    folder::arg::name::FolderNameArg,
+    printer::Printer,
 };
 
 /// Create a new folder.
@@ -25,19 +33,43 @@ pub struct FolderCreateCommand {
 
 impl FolderCreateCommand {
     pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
-        info!("executing folder create command");
+        info!("executing create folder command");
 
         let folder = &self.folder.name;
+        let (toml_account_config, account_config) = config.clone().into_account_configs(
+            self.account.name.as_ref().map(String::as_str),
+            self.cache.disable,
+        )?;
 
-        let some_account_name = self.account.name.as_ref().map(String::as_str);
-        let (toml_account_config, account_config) = config
-            .clone()
-            .into_account_configs(some_account_name, self.cache.disable)?;
-        let backend = Backend::new(toml_account_config, account_config.clone(), false).await?;
+        let add_folder_kind = toml_account_config.add_folder_kind();
+
+        let backend = Backend::new(
+            &toml_account_config,
+            &account_config,
+            add_folder_kind,
+            |builder| match add_folder_kind {
+                Some(BackendKind::Maildir) => {
+                    builder
+                        .set_add_folder(|ctx| ctx.maildir.as_ref().and_then(AddFolderMaildir::new));
+                }
+                Some(BackendKind::MaildirForSync) => {
+                    builder.set_add_folder(|ctx| {
+                        ctx.maildir_for_sync
+                            .as_ref()
+                            .and_then(AddFolderMaildir::new)
+                    });
+                }
+                #[cfg(feature = "imap")]
+                Some(BackendKind::Imap) => {
+                    builder.set_add_folder(|ctx| ctx.imap.as_ref().and_then(AddFolderImap::new));
+                }
+                _ => (),
+            },
+        )
+        .await?;
 
         backend.add_folder(&folder).await?;
-        printer.print(format!("Folder {folder} successfully created!"))?;
 
-        Ok(())
+        printer.print(format!("Folder {folder} successfully created!"))
     }
 }

src/folder/command/delete.rs

@@ -1,12 +1,20 @@
 use anyhow::Result;
 use clap::Parser;
 use dialoguer::Confirm;
+#[cfg(feature = "imap")]
+use email::folder::delete::imap::DeleteFolderImap;
+#[cfg(feature = "maildir")]
+use email::folder::delete::maildir::DeleteFolderMaildir;
 use log::info;
 use std::process;
 
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, cache::arg::disable::CacheDisableFlag,
-    config::TomlConfig, folder::arg::name::FolderNameArg, printer::Printer,
+    account::arg::name::AccountNameFlag,
+    backend::{Backend, BackendKind},
+    cache::arg::disable::CacheDisableFlag,
+    config::TomlConfig,
+    folder::arg::name::FolderNameArg,
+    printer::Printer,
 };
 
 /// Delete a folder.
@@ -41,15 +49,42 @@ impl FolderDeleteCommand {
             process::exit(0);
         };
 
-        let some_account_name = self.account.name.as_ref().map(String::as_str);
-        let (toml_account_config, account_config) = config
-            .clone()
-            .into_account_configs(some_account_name, self.cache.disable)?;
-        let backend = Backend::new(toml_account_config, account_config.clone(), false).await?;
+        let (toml_account_config, account_config) = config.clone().into_account_configs(
+            self.account.name.as_ref().map(String::as_str),
+            self.cache.disable,
+        )?;
+
+        let delete_folder_kind = toml_account_config.delete_folder_kind();
+
+        let backend = Backend::new(
+            &toml_account_config,
+            &account_config,
+            delete_folder_kind,
+            |builder| match delete_folder_kind {
+                Some(BackendKind::Maildir) => {
+                    builder.set_delete_folder(|ctx| {
+                        ctx.maildir.as_ref().and_then(DeleteFolderMaildir::new)
+                    });
+                }
+                Some(BackendKind::MaildirForSync) => {
+                    builder.set_delete_folder(|ctx| {
+                        ctx.maildir_for_sync
+                            .as_ref()
+                            .and_then(DeleteFolderMaildir::new)
+                    });
+                }
+                #[cfg(feature = "imap")]
+                Some(BackendKind::Imap) => {
+                    builder
+                        .set_delete_folder(|ctx| ctx.imap.as_ref().and_then(DeleteFolderImap::new));
+                }
+                _ => (),
+            },
+        )
+        .await?;
 
         backend.delete_folder(&folder).await?;
-        printer.print(format!("Folder {folder} successfully deleted!"))?;
 
-        Ok(())
+        printer.print(format!("Folder {folder} successfully deleted!"))
     }
 }

src/folder/command/expunge.rs

@@ -1,10 +1,18 @@
 use anyhow::Result;
 use clap::Parser;
+#[cfg(feature = "imap")]
+use email::folder::expunge::imap::ExpungeFolderImap;
+#[cfg(feature = "maildir")]
+use email::folder::expunge::maildir::ExpungeFolderMaildir;
 use log::info;
 
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, cache::arg::disable::CacheDisableFlag,
-    config::TomlConfig, folder::arg::name::FolderNameArg, printer::Printer,
+    account::arg::name::AccountNameFlag,
+    backend::{Backend, BackendKind},
+    cache::arg::disable::CacheDisableFlag,
+    config::TomlConfig,
+    folder::arg::name::FolderNameArg,
+    printer::Printer,
 };
 
 /// Expunge a folder.
@@ -26,19 +34,46 @@ pub struct FolderExpungeCommand {
 
 impl FolderExpungeCommand {
     pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
-        info!("executing folder expunge command");
+        info!("executing expunge folder command");
 
         let folder = &self.folder.name;
+        let (toml_account_config, account_config) = config.clone().into_account_configs(
+            self.account.name.as_ref().map(String::as_str),
+            self.cache.disable,
+        )?;
 
-        let some_account_name = self.account.name.as_ref().map(String::as_str);
-        let (toml_account_config, account_config) = config
-            .clone()
-            .into_account_configs(some_account_name, self.cache.disable)?;
-        let backend = Backend::new(toml_account_config, account_config.clone(), false).await?;
+        let expunge_folder_kind = toml_account_config.expunge_folder_kind();
+
+        let backend = Backend::new(
+            &toml_account_config,
+            &account_config,
+            expunge_folder_kind,
+            |builder| match expunge_folder_kind {
+                Some(BackendKind::Maildir) => {
+                    builder.set_expunge_folder(|ctx| {
+                        ctx.maildir.as_ref().and_then(ExpungeFolderMaildir::new)
+                    });
+                }
+                Some(BackendKind::MaildirForSync) => {
+                    builder.set_expunge_folder(|ctx| {
+                        ctx.maildir_for_sync
+                            .as_ref()
+                            .and_then(ExpungeFolderMaildir::new)
+                    });
+                }
+                #[cfg(feature = "imap")]
+                Some(BackendKind::Imap) => {
+                    builder.set_expunge_folder(|ctx| {
+                        ctx.imap.as_ref().and_then(ExpungeFolderImap::new)
+                    });
+                }
+                _ => (),
+            },
+        )
+        .await?;
 
         backend.expunge_folder(&folder).await?;
-        printer.print(format!("Folder {folder} successfully expunged!"))?;
 
-        Ok(())
+        printer.print(format!("Folder {folder} successfully expunged!"))
     }
 }

src/folder/command/list.rs

@@ -1,10 +1,14 @@
 use anyhow::Result;
 use clap::Parser;
+#[cfg(feature = "imap")]
+use email::folder::list::imap::ListFoldersImap;
+#[cfg(feature = "maildir")]
+use email::folder::list::maildir::ListFoldersMaildir;
 use log::info;
 
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
+    backend::{Backend, BackendKind},
     cache::arg::disable::CacheDisableFlag,
     config::TomlConfig,
     folder::Folders,
@@ -29,13 +33,41 @@ pub struct FolderListCommand {
 
 impl FolderListCommand {
     pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
-        info!("executing folder list command");
+        info!("executing list folders command");
 
-        let some_account_name = self.account.name.as_ref().map(String::as_str);
-        let (toml_account_config, account_config) = config
-            .clone()
-            .into_account_configs(some_account_name, self.cache.disable)?;
-        let backend = Backend::new(toml_account_config, account_config.clone(), false).await?;
+        let (toml_account_config, account_config) = config.clone().into_account_configs(
+            self.account.name.as_ref().map(String::as_str),
+            self.cache.disable,
+        )?;
+
+        let list_folders_kind = toml_account_config.list_folders_kind();
+
+        let backend = Backend::new(
+            &toml_account_config,
+            &account_config,
+            list_folders_kind,
+            |builder| match list_folders_kind {
+                Some(BackendKind::Maildir) => {
+                    builder.set_list_folders(|ctx| {
+                        ctx.maildir.as_ref().and_then(ListFoldersMaildir::new)
+                    });
+                }
+                Some(BackendKind::MaildirForSync) => {
+                    builder.set_list_folders(|ctx| {
+                        ctx.maildir_for_sync
+                            .as_ref()
+                            .and_then(ListFoldersMaildir::new)
+                    });
+                }
+                #[cfg(feature = "imap")]
+                Some(BackendKind::Imap) => {
+                    builder
+                        .set_list_folders(|ctx| ctx.imap.as_ref().and_then(ListFoldersImap::new));
+                }
+                _ => (),
+            },
+        )
+        .await?;
 
         let folders: Folders = backend.list_folders().await?.into();
 
@@ -45,8 +77,6 @@ impl FolderListCommand {
                 format: &account_config.get_message_read_format(),
                 max_width: self.table.max_width,
             },
-        )?;
-
-        Ok(())
+        )
     }
 }

src/folder/command/purge.rs

@@ -1,12 +1,18 @@
 use anyhow::Result;
 use clap::Parser;
 use dialoguer::Confirm;
+#[cfg(feature = "imap")]
+use email::folder::purge::imap::PurgeFolderImap;
 use log::info;
 use std::process;
 
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, cache::arg::disable::CacheDisableFlag,
-    config::TomlConfig, folder::arg::name::FolderNameArg, printer::Printer,
+    account::arg::name::AccountNameFlag,
+    backend::{Backend, BackendKind},
+    cache::arg::disable::CacheDisableFlag,
+    config::TomlConfig,
+    folder::arg::name::FolderNameArg,
+    printer::Printer,
 };
 
 /// Purge a folder.
@@ -27,7 +33,7 @@ pub struct FolderPurgeCommand {
 
 impl FolderPurgeCommand {
     pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
-        info!("executing folder purge command");
+        info!("executing purge folder command");
 
         let folder = &self.folder.name;
 
@@ -41,15 +47,43 @@ impl FolderPurgeCommand {
             process::exit(0);
         };
 
-        let some_account_name = self.account.name.as_ref().map(String::as_str);
-        let (toml_account_config, account_config) = config
-            .clone()
-            .into_account_configs(some_account_name, self.cache.disable)?;
-        let backend = Backend::new(toml_account_config, account_config.clone(), false).await?;
+        let (toml_account_config, account_config) = config.clone().into_account_configs(
+            self.account.name.as_ref().map(String::as_str),
+            self.cache.disable,
+        )?;
+
+        let purge_folder_kind = toml_account_config.purge_folder_kind();
+
+        let backend = Backend::new(
+            &toml_account_config,
+            &account_config,
+            purge_folder_kind,
+            |builder| match purge_folder_kind {
+                // TODO
+                // Some(BackendKind::Maildir) => {
+                //     builder.set_purge_folder(|ctx| {
+                //         ctx.maildir.as_ref().and_then(PurgeFolderMaildir::new)
+                //     });
+                // }
+                // Some(BackendKind::MaildirForSync) => {
+                //     builder.set_purge_folder(|ctx| {
+                //         ctx.maildir_for_sync
+                //             .as_ref()
+                //             .and_then(PurgeFolderMaildir::new)
+                //     });
+                // }
+                #[cfg(feature = "imap")]
+                Some(BackendKind::Imap) => {
+                    builder
+                        .set_purge_folder(|ctx| ctx.imap.as_ref().and_then(PurgeFolderImap::new));
+                }
+                _ => (),
+            },
+        )
+        .await?;
 
         backend.purge_folder(&folder).await?;
-        printer.print(format!("Folder {folder} successfully purged!"))?;
 
-        Ok(())
+        printer.print(format!("Folder {folder} successfully purged!"))
     }
 }