performance improvements

src/interactive.rs

@@ -1,16 +1,9 @@
 use crate::formatter::Formatter;
 use crate::{fileinfo::FileInfo, params::Params};
 use anyhow::Result;
-use colored::Colorize;
 use dashmap::DashMap;
-use indicatif::{ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressStyle};
 use prettytable::{format, row, Table};
-use rayon::prelude::*;
-use std::{
-    borrow::Cow,
-    io::{self, Write},
-    time::Duration,
-};
+use std::io::{self, Write};
 
 pub fn scan_group_confirmation() -> Result<bool> {
     print!("\nconfirm? [y/N]: ");
@@ -36,43 +29,8 @@ pub fn scan_group_instruction() -> Result<String> {
     Ok(user_input)
 }
 
-pub fn init(result: Vec<FileInfo>, app_args: &Params) -> Result<()> {
-    let basepath_length = app_args.get_directory()?.to_str().unwrap_or_default().len();
-    let max_filepath_length = result
-        .iter()
-        .map(|file| file.path.to_str().unwrap_or_default().len())
-        .max()
-        .unwrap_or_default();
-
-    let min_path_length = if max_filepath_length > basepath_length {
-        max_filepath_length - basepath_length
-    } else {
-        0
-    };
-
-    let progress_style = ProgressStyle::with_template(
-        "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
-    )?;
-    let progress_bar = ProgressBar::new(result.len() as u64);
-    progress_bar.set_style(progress_style);
-    progress_bar.enable_steady_tick(Duration::from_millis(50));
-    progress_bar.set_message("reconciling data");
-
-    let duplicates: DashMap<String, Vec<FileInfo>> = DashMap::new();
+pub fn init(result: DashMap<String, Vec<FileInfo>>, app_args: &Params) -> Result<()> {
     result
-        .into_par_iter()
-        .progress_with(progress_bar)
-        .with_finish(ProgressFinish::WithMessage(Cow::from("data reconciled")))
-        .map(|file| file.hash())
-        .filter_map(Result::ok)
-        .for_each(|file| {
-            duplicates
-                .entry(file.hash.clone().unwrap_or_default())
-                .and_modify(|fileset| fileset.push(file.clone()))
-                .or_insert_with(|| vec![file]);
-        });
-
-    duplicates
         .clone()
         .into_iter()
         .enumerate()
@@ -80,18 +38,22 @@ pub fn init(result: Vec<FileInfo>, app_args: &Params) -> Result<()> {
             let mut itable = Table::new();
             itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
             itable.set_titles(row!["index", "filename", "size", "updated_at"]);
+            let max_path_size = group
+                .iter()
+                .map(|f| f.path.clone().into_os_string().len())
+                .max()
+                .unwrap_or_default();
+
             group.iter().enumerate().for_each(|(index, file)| {
                 itable.add_row(row![
                     index,
-                    Formatter::human_path(file, app_args, min_path_length)
-                        .unwrap_or_default()
-                        .blue(),
-                    Formatter::human_filesize(file).unwrap_or_default().red(),
-                    Formatter::human_mtime(file).unwrap_or_default().yellow()
+                    Formatter::human_path(file, app_args, max_path_size).unwrap_or_default(),
+                    Formatter::human_filesize(file).unwrap_or_default(),
+                    Formatter::human_mtime(file).unwrap_or_default()
                 ]);
             });
 
-            process_group_action(&group, gindex, duplicates.len(), itable);
+            process_group_action(&group, gindex, result.len(), itable);
         });
 
     Ok(())
@@ -118,7 +80,7 @@ pub fn process_group_action(
         .into_iter()
         .any(|index| index > (duplicates.len() - 1))
     {
-        println!("{}", "Err: File Index Out of Bounds!".red());
+        println!("Err: File Index Out of Bounds!");
         return process_group_action(duplicates, dup_index, dup_size, table);
     }
 
@@ -132,23 +94,23 @@ pub fn process_group_action(
         .into_iter()
         .map(|index| duplicates[index].clone());
 
-    println!("\n{}", "The following files will be deleted:".red());
+    println!("\nThe following files will be deleted:");
     files_to_delete
         .clone()
         .enumerate()
         .for_each(|(index, file)| {
-            println!("{}: {}", index.to_string().blue(), file.path.display());
+            println!("{}: {}", index, file.path.display());
         });
 
     match scan_group_confirmation().unwrap() {
         true => {
             files_to_delete.into_iter().for_each(|file| {
                 match std::fs::remove_file(file.path.clone()) {
-                    Ok(_) => println!("{}: {}", "DELETED".green(), file.path.display()),
-                    Err(_) => println!("{}: {}", "FAILED".red(), file.path.display()),
+                    Ok(_) => println!("DELETED: {}", file.path.display()),
+                    Err(_) => println!("FAILED: {}", file.path.display()),
                 }
             });
         }
-        false => println!("{}", "\nCancelled Delete Operation.".red()),
+        false => println!("\nCancelled Delete Operation."),
     }
 }