wip: use shared stuff from pimalaya-tui

src/email/message/command/copy.rs

@@ -1,15 +1,19 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
-    config::Config,
+    config::TomlConfig,
     envelope::arg::ids::EnvelopeIdsArgs,
     folder::arg::name::{SourceFolderNameOptionalFlag, TargetFolderNameArg},
-    printer::Printer,
 };
 
 /// Copy a message from a source folder to a target folder.
@@ -29,7 +33,7 @@ pub struct MessageCopyCommand {
 }
 
 impl MessageCopyCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing copy message(s) command");
 
         let source = &self.source_folder.name;
@@ -40,20 +44,22 @@ impl MessageCopyCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let copy_messages_kind = toml_account_config.copy_messages_kind();
-
-        let backend = Backend::new(
-            toml_account_config.clone(),
-            account_config,
-            copy_messages_kind,
-            |builder| builder.set_copy_messages(BackendFeatureSource::Context),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
+            Arc::new(account_config),
+            |builder| {
+                builder
+                    .without_features()
+                    .with_copy_messages(BackendFeatureSource::Context)
+            },
         )
+        .build()
         .await?;
 
         backend.copy_messages(source, target, ids).await?;
 
         printer.out(format!(
-            "Message(s) successfully copied from {source} to {target}!"
+            "Message(s) successfully copied from {source} to {target}!\n"
         ))
     }
 }

src/email/message/command/delete.rs

@@ -1,12 +1,17 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config,
-    envelope::arg::ids::EnvelopeIdsArgs, folder::arg::name::FolderNameOptionalFlag,
-    printer::Printer,
+    account::arg::name::AccountNameFlag, config::TomlConfig, envelope::arg::ids::EnvelopeIdsArgs,
+    folder::arg::name::FolderNameOptionalFlag,
 };
 
 /// Mark as deleted a message from a folder.
@@ -28,7 +33,7 @@ pub struct MessageDeleteCommand {
 }
 
 impl MessageDeleteCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing delete message(s) command");
 
         let folder = &self.folder.name;
@@ -38,18 +43,20 @@ impl MessageDeleteCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let delete_messages_kind = toml_account_config.delete_messages_kind();
-
-        let backend = Backend::new(
-            toml_account_config.clone(),
-            account_config,
-            delete_messages_kind,
-            |builder| builder.set_delete_messages(BackendFeatureSource::Context),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
+            Arc::new(account_config),
+            |builder| {
+                builder
+                    .without_features()
+                    .with_delete_messages(BackendFeatureSource::Context)
+            },
         )
+        .build()
         .await?;
 
         backend.delete_messages(folder, ids).await?;
 
-        printer.out(format!("Message(s) successfully removed from {folder}!"))
+        printer.out(format!("Message(s) successfully removed from {folder}!\n"))
     }
 }

src/email/message/command/forward.rs

@@ -1,17 +1,20 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::{eyre::eyre, Result};
 use email::backend::feature::BackendFeatureSource;
+use pimalaya_tui::{
+    himalaya::{backend::BackendBuilder, editor},
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
-    config::Config,
+    config::TomlConfig,
     envelope::arg::ids::EnvelopeIdArg,
     folder::arg::name::FolderNameOptionalFlag,
     message::arg::{body::MessageRawBodyArg, header::HeaderRawArgs},
-    printer::Printer,
-    ui::editor,
 };
 
 /// Forward a message.
@@ -39,7 +42,7 @@ pub struct MessageForwardCommand {
 }
 
 impl MessageForwardCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing forward message command");
 
         let folder = &self.folder.name;
@@ -48,18 +51,19 @@ impl MessageForwardCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let add_message_kind = toml_account_config.add_message_kind();
-        let send_message_kind = toml_account_config.send_message_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            add_message_kind.into_iter().chain(send_message_kind),
             |builder| {
-                builder.set_add_message(BackendFeatureSource::Context);
-                builder.set_send_message(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+                    .with_send_message(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let id = self.envelope.id;

src/email/message/command/mailto.rs

@@ -1,14 +1,17 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
 use mail_builder::MessageBuilder;
+use pimalaya_tui::{
+    himalaya::{backend::BackendBuilder, editor},
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 use url::Url;
 
-use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config, printer::Printer,
-    ui::editor,
-};
+use crate::{account::arg::name::AccountNameFlag, config::TomlConfig};
 
 /// Parse and edit a message from a mailto URL string.
 ///
@@ -34,25 +37,26 @@ impl MessageMailtoCommand {
         })
     }
 
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing mailto message command");
 
         let (toml_account_config, account_config) = config
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let add_message_kind = toml_account_config.add_message_kind();
-        let send_message_kind = toml_account_config.send_message_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            add_message_kind.into_iter().chain(send_message_kind),
             |builder| {
-                builder.set_add_message(BackendFeatureSource::Context);
-                builder.set_send_message(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+                    .with_send_message(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let mut builder = MessageBuilder::new().to(self.url.path());

src/email/message/command/mod.rs

@@ -12,8 +12,9 @@ pub mod write;
 
 use clap::Subcommand;
 use color_eyre::Result;
+use pimalaya_tui::terminal::cli::printer::Printer;
 
-use crate::{config::Config, printer::Printer};
+use crate::config::TomlConfig;
 
 use self::{
     copy::MessageCopyCommand, delete::MessageDeleteCommand, forward::MessageForwardCommand,
@@ -67,7 +68,7 @@ pub enum MessageSubcommand {
 
 impl MessageSubcommand {
     #[allow(unused)]
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         match self {
             Self::Read(cmd) => cmd.execute(printer, config).await,
             Self::Thread(cmd) => cmd.execute(printer, config).await,

src/email/message/command/move.rs

@@ -1,16 +1,20 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 #[allow(unused)]
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
-    config::Config,
+    config::TomlConfig,
     envelope::arg::ids::EnvelopeIdsArgs,
     folder::arg::name::{SourceFolderNameOptionalFlag, TargetFolderNameArg},
-    printer::Printer,
 };
 
 /// Move a message from a source folder to a target folder.
@@ -30,7 +34,7 @@ pub struct MessageMoveCommand {
 }
 
 impl MessageMoveCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing move message(s) command");
 
         let source = &self.source_folder.name;
@@ -41,20 +45,22 @@ impl MessageMoveCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let move_messages_kind = toml_account_config.move_messages_kind();
-
-        let backend = Backend::new(
-            toml_account_config.clone(),
-            account_config,
-            move_messages_kind,
-            |builder| builder.set_move_messages(BackendFeatureSource::Context),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
+            Arc::new(account_config),
+            |builder| {
+                builder
+                    .without_features()
+                    .with_move_messages(BackendFeatureSource::Context)
+            },
         )
+        .build()
         .await?;
 
         backend.move_messages(source, target, ids).await?;
 
         printer.out(format!(
-            "Message(s) successfully moved from {source} to {target}!"
+            "Message(s) successfully moved from {source} to {target}!\n"
         ))
     }
 }

src/email/message/command/read.rs

@@ -1,14 +1,19 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
 use mml::message::FilterParts;
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 #[allow(unused)]
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config,
-    envelope::arg::ids::EnvelopeIdsArgs, folder::arg::name::FolderNameOptionalFlag,
-    printer::Printer,
+    account::arg::name::AccountNameFlag, config::TomlConfig, envelope::arg::ids::EnvelopeIdsArgs,
+    folder::arg::name::FolderNameOptionalFlag,
 };
 
 /// Read a message.
@@ -73,7 +78,7 @@ pub struct MessageReadCommand {
 }
 
 impl MessageReadCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing read message(s) command");
 
         let folder = &self.folder.name;
@@ -83,14 +88,18 @@ impl MessageReadCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let get_messages_kind = toml_account_config.get_messages_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            get_messages_kind,
-            |builder| builder.set_get_messages(BackendFeatureSource::Context),
+            |builder| {
+                builder
+                    .without_features()
+                    .with_get_messages(BackendFeatureSource::Context)
+            },
         )
+        .build()
         .await?;
 
         let emails = if self.preview {

src/email/message/command/reply.rs

@@ -1,17 +1,20 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::{eyre::eyre, Result};
 use email::backend::feature::BackendFeatureSource;
+use pimalaya_tui::{
+    himalaya::{backend::BackendBuilder, editor},
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
-    config::Config,
+    config::TomlConfig,
     envelope::arg::ids::EnvelopeIdArg,
     folder::arg::name::FolderNameOptionalFlag,
     message::arg::{body::MessageRawBodyArg, header::HeaderRawArgs, reply::MessageReplyAllArg},
-    printer::Printer,
-    ui::editor,
 };
 
 /// Reply to a message.
@@ -42,7 +45,7 @@ pub struct MessageReplyCommand {
 }
 
 impl MessageReplyCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing reply message command");
 
         let folder = &self.folder.name;
@@ -50,18 +53,19 @@ impl MessageReplyCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let add_message_kind = toml_account_config.add_message_kind();
-        let send_message_kind = toml_account_config.send_message_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            add_message_kind.into_iter().chain(send_message_kind),
             |builder| {
-                builder.set_add_message(BackendFeatureSource::Context);
-                builder.set_send_message(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+                    .with_send_message(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let id = self.envelope.id;

src/email/message/command/save.rs

@@ -1,13 +1,19 @@
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
-use std::io::{self, BufRead, IsTerminal};
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
+use std::{
+    io::{self, BufRead, IsTerminal},
+    sync::Arc,
+};
 use tracing::info;
 
-#[allow(unused)]
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config,
-    folder::arg::name::FolderNameOptionalFlag, message::arg::MessageRawArg, printer::Printer,
+    account::arg::name::AccountNameFlag, config::TomlConfig,
+    folder::arg::name::FolderNameOptionalFlag, message::arg::MessageRawArg,
 };
 
 /// Save a message to a folder.
@@ -26,7 +32,7 @@ pub struct MessageSaveCommand {
 }
 
 impl MessageSaveCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing save message command");
 
         let folder = &self.folder.name;
@@ -35,14 +41,16 @@ impl MessageSaveCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let add_message_kind = toml_account_config.add_message_kind();
-
-        let backend = Backend::new(
-            toml_account_config.clone(),
-            account_config,
-            add_message_kind,
-            |builder| builder.set_add_message(BackendFeatureSource::Context),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
+            Arc::new(account_config),
+            |builder| {
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+            },
         )
+        .build()
         .await?;
 
         let is_tty = io::stdin().is_terminal();
@@ -60,6 +68,6 @@ impl MessageSaveCommand {
 
         backend.add_message(folder, msg.as_bytes()).await?;
 
-        printer.out(format!("Message successfully saved to {folder}!"))
+        printer.out(format!("Message successfully saved to {folder}!\n"))
     }
 }

src/email/message/command/send.rs

@@ -1,13 +1,17 @@
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
-use std::io::{self, BufRead, IsTerminal};
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
+use std::{
+    io::{self, BufRead, IsTerminal},
+    sync::Arc,
+};
 use tracing::info;
 
-use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config,
-    message::arg::MessageRawArg, printer::Printer,
-};
+use crate::{account::arg::name::AccountNameFlag, config::TomlConfig, message::arg::MessageRawArg};
 
 /// Send a message.
 ///
@@ -23,28 +27,24 @@ pub struct MessageSendCommand {
 }
 
 impl MessageSendCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing send message command");
 
         let (toml_account_config, account_config) = config
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let send_message_kind = toml_account_config.send_message_kind().into_iter().chain(
-            toml_account_config
-                .add_message_kind()
-                .filter(|_| account_config.should_save_copy_sent_message()),
-        );
-
-        let backend = Backend::new(
-            toml_account_config.clone(),
-            account_config,
-            send_message_kind,
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
+            Arc::new(account_config),
             |builder| {
-                builder.set_send_message(BackendFeatureSource::Context);
-                builder.set_add_message(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+                    .with_send_message(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let msg = if io::stdin().is_terminal() {

src/email/message/command/thread.rs

@@ -1,15 +1,20 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::backend::feature::BackendFeatureSource;
 use mml::message::FilterParts;
+use pimalaya_tui::{
+    himalaya::backend::BackendBuilder,
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::envelope::arg::ids::EnvelopeIdArg;
 #[allow(unused)]
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::Config,
-    envelope::arg::ids::EnvelopeIdsArgs, folder::arg::name::FolderNameOptionalFlag,
-    printer::Printer,
+    account::arg::name::AccountNameFlag, config::TomlConfig, envelope::arg::ids::EnvelopeIdsArgs,
+    folder::arg::name::FolderNameOptionalFlag,
 };
 
 /// Thread a message.
@@ -74,7 +79,7 @@ pub struct MessageThreadCommand {
 }
 
 impl MessageThreadCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing thread message(s) command");
 
         let folder = &self.folder.name;
@@ -84,17 +89,19 @@ impl MessageThreadCommand {
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let get_messages_kind = toml_account_config.get_messages_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            get_messages_kind,
             |builder| {
-                builder.set_thread_envelopes(BackendFeatureSource::Context);
-                builder.set_get_messages(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_get_messages(BackendFeatureSource::Context)
+                    .with_thread_envelopes(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let envelopes = backend

src/email/message/command/write.rs

@@ -1,15 +1,18 @@
+use std::sync::Arc;
+
 use clap::Parser;
 use color_eyre::Result;
 use email::{backend::feature::BackendFeatureSource, message::Message};
+use pimalaya_tui::{
+    himalaya::{backend::BackendBuilder, editor},
+    terminal::{cli::printer::Printer, config::TomlConfig as _},
+};
 use tracing::info;
 
 use crate::{
     account::arg::name::AccountNameFlag,
-    backend::Backend,
-    config::Config,
+    config::TomlConfig,
     message::arg::{body::MessageRawBodyArg, header::HeaderRawArgs},
-    printer::Printer,
-    ui::editor,
 };
 
 /// Write a new message.
@@ -31,25 +34,26 @@ pub struct MessageWriteCommand {
 }
 
 impl MessageWriteCommand {
-    pub async fn execute(self, printer: &mut impl Printer, config: &Config) -> Result<()> {
+    pub async fn execute(self, printer: &mut impl Printer, config: &TomlConfig) -> Result<()> {
         info!("executing write message command");
 
         let (toml_account_config, account_config) = config
             .clone()
             .into_account_configs(self.account.name.as_deref())?;
 
-        let add_message_kind = toml_account_config.add_message_kind();
-        let send_message_kind = toml_account_config.send_message_kind();
+        let account_config = Arc::new(account_config);
 
-        let backend = Backend::new(
-            toml_account_config.clone(),
+        let backend = BackendBuilder::new(
+            Arc::new(toml_account_config),
             account_config.clone(),
-            add_message_kind.into_iter().chain(send_message_kind),
             |builder| {
-                builder.set_add_message(BackendFeatureSource::Context);
-                builder.set_send_message(BackendFeatureSource::Context);
+                builder
+                    .without_features()
+                    .with_add_message(BackendFeatureSource::Context)
+                    .with_send_message(BackendFeatureSource::Context)
             },
         )
+        .build()
         .await?;
 
         let tpl = Message::new_tpl_builder(account_config.clone())