wip: fix printer, make thread compatible with it

src/folder/command/add.rs

@@ -50,6 +50,6 @@ impl AddFolderCommand {
 
         backend.add_folder(folder).await?;
 
-        printer.print(format!("Folder {folder} successfully created!"))
+        printer.log(format!("Folder {folder} successfully created!"))
     }
 }

src/folder/command/delete.rs

@@ -60,6 +60,6 @@ impl FolderDeleteCommand {
 
         backend.delete_folder(folder).await?;
 
-        printer.print(format!("Folder {folder} successfully deleted!"))
+        printer.log(format!("Folder {folder} successfully deleted!"))
     }
 }

src/folder/command/expunge.rs

@@ -51,6 +51,6 @@ impl FolderExpungeCommand {
 
         backend.expunge_folder(folder).await?;
 
-        printer.print(format!("Folder {folder} successfully expunged!"))
+        printer.log(format!("Folder {folder} successfully expunged!"))
     }
 }

src/folder/command/list.rs

@@ -6,7 +6,10 @@ use tracing::info;
 #[cfg(feature = "account-sync")]
 use crate::cache::arg::disable::CacheDisableFlag;
 use crate::{
-    account::arg::name::AccountNameFlag, backend::Backend, config::TomlConfig, folder::Folders,
+    account::arg::name::AccountNameFlag,
+    backend::Backend,
+    config::TomlConfig,
+    folder::{Folders, FoldersTable},
     printer::Printer,
 };
 
@@ -51,9 +54,10 @@ impl FolderListCommand {
         )
         .await?;
 
-        let folders: Folders = backend.list_folders().await?.into();
+        let folders = Folders::from(backend.list_folders().await?);
+        let table = FoldersTable::from(folders).with_some_width(self.table_max_width);
 
-        printer.print_table(folders, self.table_max_width)?;
+        printer.log(table)?;
         Ok(())
     }
 }

src/folder/command/purge.rs

@@ -60,6 +60,6 @@ impl FolderPurgeCommand {
 
         backend.purge_folder(folder).await?;
 
-        printer.print(format!("Folder {folder} successfully purged!"))
+        printer.log(format!("Folder {folder} successfully purged!"))
     }
 }

src/folder/mod.rs

@@ -2,12 +2,9 @@ pub mod arg;
 pub mod command;
 pub mod config;
 
-use color_eyre::Result;
-use comfy_table::{presets, Attribute, Cell, ContentArrangement, Row, Table};
-use serde::Serialize;
-use std::ops;
-
-use crate::printer::{PrintTable, WriteColor};
+use comfy_table::{presets, Attribute, Cell, Row, Table};
+use serde::{Serialize, Serializer};
+use std::{fmt, ops::Deref};
 
 #[derive(Clone, Debug, Default, Serialize)]
 pub struct Folder {
@@ -15,67 +12,46 @@ pub struct Folder {
     pub desc: String,
 }
 
-impl From<&email::folder::Folder> for Folder {
-    fn from(folder: &email::folder::Folder) -> Self {
+impl Folder {
+    pub fn to_row(&self) -> Row {
+        let mut row = Row::new();
+
+        row.add_cell(Cell::new(&self.name).fg(comfy_table::Color::Blue));
+        row.add_cell(Cell::new(&self.desc).fg(comfy_table::Color::Green));
+
+        row
+    }
+}
+
+impl From<email::folder::Folder> for Folder {
+    fn from(folder: email::folder::Folder) -> Self {
         Folder {
-            name: folder.name.clone(),
-            desc: folder.desc.clone(),
+            name: folder.name,
+            desc: folder.desc,
         }
     }
 }
-impl From<&Folder> for Row {
-    fn from(folder: &Folder) -> Self {
-        let mut row = Row::new();
-        row.add_cell(Cell::new(&folder.name).fg(comfy_table::Color::Blue));
-        row.add_cell(Cell::new(&folder.desc).fg(comfy_table::Color::Green));
-
-        row
-    }
-}
-
-impl From<Folder> for Row {
-    fn from(folder: Folder) -> Self {
-        let mut row = Row::new();
-        row.add_cell(Cell::new(folder.name).fg(comfy_table::Color::Blue));
-        row.add_cell(Cell::new(folder.desc).fg(comfy_table::Color::Green));
-
-        row
-    }
-}
 
 #[derive(Clone, Debug, Default, Serialize)]
 pub struct Folders(Vec<Folder>);
 
-impl From<Folders> for Table {
-    fn from(folders: Folders) -> Self {
+impl Folders {
+    pub fn to_table(&self) -> Table {
         let mut table = Table::new();
+
         table
             .load_preset(presets::NOTHING)
             .set_header(Row::from([
                 Cell::new("NAME").add_attribute(Attribute::Reverse),
                 Cell::new("DESC").add_attribute(Attribute::Reverse),
             ]))
-            .add_rows(folders.0.into_iter().map(Row::from));
+            .add_rows(self.iter().map(Folder::to_row));
+
         table
     }
 }
 
-impl From<&Folders> for Table {
-    fn from(folders: &Folders) -> Self {
-        let mut table = Table::new();
-        table
-            .load_preset(presets::NOTHING)
-            .set_content_arrangement(ContentArrangement::Dynamic)
-            .set_header(Row::from([
-                Cell::new("NAME").add_attribute(Attribute::Reverse),
-                Cell::new("DESC").add_attribute(Attribute::Reverse),
-            ]))
-            .add_rows(folders.0.iter().map(Row::from));
-        table
-    }
-}
-
-impl ops::Deref for Folders {
+impl Deref for Folders {
     type Target = Vec<Folder>;
 
     fn deref(&self) -> &Self::Target {
@@ -85,19 +61,51 @@ impl ops::Deref for Folders {
 
 impl From<email::folder::Folders> for Folders {
     fn from(folders: email::folder::Folders) -> Self {
-        Folders(folders.iter().map(Folder::from).collect())
+        Folders(folders.into_iter().map(Folder::from).collect())
     }
 }
 
-impl PrintTable for Folders {
-    fn print_table(&self, writer: &mut dyn WriteColor, table_max_width: Option<u16>) -> Result<()> {
-        let mut table = Table::from(self);
-        if let Some(width) = table_max_width {
+pub struct FoldersTable {
+    folders: Folders,
+    width: Option<u16>,
+}
+
+impl FoldersTable {
+    pub fn with_some_width(mut self, width: Option<u16>) -> Self {
+        self.width = width;
+        self
+    }
+}
+
+impl From<Folders> for FoldersTable {
+    fn from(folders: Folders) -> Self {
+        Self {
+            folders,
+            width: None,
+        }
+    }
+}
+
+impl fmt::Display for FoldersTable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut table = self.folders.to_table();
+
+        if let Some(width) = self.width {
             table.set_width(width);
         }
-        writeln!(writer)?;
-        write!(writer, "{}", table)?;
-        writeln!(writer)?;
+
+        writeln!(f)?;
+        write!(f, "{table}")?;
+        writeln!(f)?;
         Ok(())
     }
 }
+
+impl Serialize for FoldersTable {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.folders.serialize(serializer)
+    }
+}