Refactored file_name collecting function: simplified and improved working with pathes

Author: PerminovEugene

src/console/messages.rs

@@ -53,7 +53,7 @@ pub fn print_processing_directory(path: &str) {
     println!("{} {:?}", "🔍 Processing directory:".green(), path);
 }
 
-pub fn print_processing_file(file_name: &str) {
+pub fn print_processing_file(file_name: &String) {
     println!("{} {:?}", "📄 Processing file:".blue(), file_name);
 }
 
@@ -102,6 +102,14 @@ pub fn print_files_not_updated() {
     println!("{}", "🚫 File locations were not updated.".yellow());
 }
 
+pub fn print_ignoring_entry(is_file: bool, path: &str) {
+    if is_file {
+        print_ignoring_file(path);
+    } else {
+        print_ignoring_folder(path);
+    }
+}
+
 pub fn print_ignoring_file(path: &str) {
     println!("{} {:?}", "⚠️ Ignoring file:".yellow(), path);
 }

src/console/table.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, path::Path};
 
 use colored::Colorize;
 use prettytable::{format, Cell, Row, Table};
@@ -28,9 +28,14 @@ pub fn print_rag_processing_result(config: &RagMlConfig, process_result: &[Proce
         } else {
             "No"
         };
+        let destination_relative_path = if result.destination_relative_path.is_empty() {
+            "./"
+        } else {
+            &result.destination_relative_path
+        };
         table.add_row(Row::new(vec![
             Cell::new(&result.source_file_name),
-            Cell::new(&result.destination_relative_path),
+            Cell::new(destination_relative_path),
             Cell::new(&result.score.to_string()),
             Cell::new(need_reorganize),
         ]));
@@ -92,32 +97,18 @@ pub fn print_migration_plan_table(files_reorganization_plan: &[FilesReorganisati
     table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
 
     files_reorganization_plan.first().iter().for_each(|plan| {
-        let from = format!("📤 From: {}", plan.source);
-        let to = format!("📥 To: {}", plan.destination);
+        let from = format!("📤 From: {}/", plan.source);
+        let to = format!("📥 To: {}/", plan.destination);
 
         table.set_titles(Row::new(vec![Cell::new(&from), Cell::new(&to)]));
     });
 
     files_reorganization_plan.iter().for_each(|plan| {
-        // separators are needed for case when inner_path == "./" to avoid double slash
-        let source_separator = if plan.source_inner_path == "./" {
-            ""
-        } else {
-            "/"
-        };
-        let destination_separator = if plan.destination_inner_path == "./" {
-            ""
-        } else {
-            "/"
-        };
-        let from = format!(
-            "{}{}{}",
-            plan.source_inner_path, source_separator, plan.file_name
-        );
-        let to = format!(
-            "{}{}{}",
-            plan.destination_inner_path, destination_separator, plan.file_name
-        );
+        let from_path = Path::new(&plan.source_inner_path).join(&plan.file_name);
+        let to_path = Path::new(&plan.destination_inner_path).join(&plan.file_name);
+
+        let from = from_path.display().to_string();
+        let to = to_path.display().to_string();
 
         table.add_row(Row::new(vec![Cell::new(&from), Cell::new(&to)]));
     });

src/errors/app_error.rs

@@ -14,4 +14,7 @@ pub enum AppError {
 
     #[error("JSON stringify error: {0}")]
     JSONStringify(String),
+
+    #[error("File processing error: {0}")]
+    FileError(String),
 }

src/files/dirr_processing.rs

@@ -1,14 +1,12 @@
-use core::panic;
 use regex::Regex;
 use std::fs;
 use std::path::Path;
 
-use crate::console::messages::print_ignoring_file;
-use crate::console::messages::print_ignoring_folder;
-use crate::console::messages::print_processing_directory;
-use crate::console::messages::print_processing_file;
-use crate::file_info::convert_path_meta_to_file_info;
-use crate::file_info::FileInfo;
+use crate::console::messages::{
+    print_ignoring_entry, print_processing_directory, print_processing_file,
+};
+use crate::errors::app_error::AppError;
+use crate::file_info::{convert_path_meta_to_file_info, FileInfo};
 
 pub struct CollectFilesMetaConfig {
     pub skip_problematic_dir: bool,
@@ -17,103 +15,133 @@ pub struct CollectFilesMetaConfig {
     pub process_files: bool,
 }
 
+/*
+  Collects file metadata and saves it to files_data vector.
+*/
 pub fn collect_files_metadata(
-    base_path_str: &Path,           // destination or source path provided in args
-    inner_path: &str,               // built during recursive calls. Use "./" for root call
-    files_data: &mut Vec<FileInfo>, // result vector
+    base_path: &Path,
+    relative_path: &Path,
+    files_data: &mut Vec<FileInfo>,
     ignore_patterns: &Vec<Regex>,
     config: &CollectFilesMetaConfig,
-) {
-    let processed_path_buf = base_path_str.join(inner_path);
-    let processed_path = processed_path_buf.as_path();
-
-    match fs::read_dir(processed_path) {
-        Ok(read_dir_res) => {
-            print_processing_directory(processed_path.to_str().unwrap());
-
-            for dir in read_dir_res.flatten() {
-                let metadata = match dir.metadata() {
-                    Ok(meta) => meta,
-                    Err(err) => {
-                        eprintln!("Error reading metadata for {:?}: {:?}", dir.path(), err);
-                        continue;
-                    }
-                };
-
-                let absolute_path = dir.path(); // begining from destination path in arg
-                let full_relative_path = match absolute_path.strip_prefix(base_path_str) {
-                    Ok(p) => p.to_path_buf(),
-                    Err(_) => absolute_path.to_path_buf(),
-                };
-                let relative_path = inner_path.to_string();
-
-                let file_name = full_relative_path
-                    .file_name()
-                    .and_then(|s| s.to_str())
-                    .unwrap_or("unknown");
-
-                if metadata.is_file() {
-                    if is_ignored(file_name, ignore_patterns) {
-                        print_ignoring_file(full_relative_path.to_str().unwrap());
-                        continue;
-                    }
-
-                    print_processing_file(file_name);
-
-                    if config.process_files {
-                        let file_info = convert_path_meta_to_file_info(
-                            &full_relative_path,
-                            relative_path,
-                            metadata,
-                            false,
-                        );
-                        files_data.push(file_info);
-                    }
-                } else {
-                    if is_ignored(file_name, ignore_patterns) {
-                        print_ignoring_folder(full_relative_path.to_str().unwrap());
-                        continue;
-                    }
-
-                    if config.process_folders {
-                        let file_info = convert_path_meta_to_file_info(
-                            &full_relative_path,
-                            relative_path,
-                            metadata,
-                            false,
-                        );
-                        files_data.push(file_info);
-                    }
-
-                    if config.recursive {
-                        if let Some(currently_processing_dir) = dir.file_name().to_str() {
-                            let full_sub_path =
-                                Path::new(inner_path).join(currently_processing_dir);
-                            let full_sub_path_str = full_sub_path.to_str().unwrap();
-
-                            collect_files_metadata(
-                                base_path_str,
-                                full_sub_path_str,
-                                files_data,
-                                ignore_patterns,
-                                config,
-                            );
-                        }
-                    }
-                }
-            }
+) -> Result<(), AppError> {
+    let processed_path = base_path.join(relative_path);
+
+    let read_dir_iter = match fs::read_dir(&processed_path) {
+        Ok(rd) => rd,
+        Err(e) => {
+            eprintln!("Error reading directory {:?}: {:?}", processed_path, e);
+            return Err(AppError::FileError(format!(
+                "Error reading directory {:?}: {}",
+                processed_path, e
+            )));
+        }
+    };
+
+    print_processing_directory(processed_path.to_str().unwrap_or("[invalid path]"));
+
+    for dir_entry_result in read_dir_iter {
+        let Some((dir, metadata)) = get_dir_entry_and_metadata(dir_entry_result, config)? else {
+            continue;
+        };
+
+        let file_name = dir.file_name().to_string_lossy().to_string(); //.to_string_lossy().to_string();
+        let is_file = metadata.is_file();
+
+        let new_relative_path = relative_path.join(&file_name);
+
+        if is_ignored(&file_name, ignore_patterns) {
+            print_ignoring_entry(is_file, new_relative_path.to_str().unwrap());
+            continue;
         }
-        Err(err) => {
-            eprintln!("Error reading directory {:?}: {:?}", processed_path, err);
-            if !config.skip_problematic_dir {
-                panic!("Error reading directory {:?}: {:?}", processed_path, err);
+
+        if is_file {
+            handle_file_entry(&file_name, relative_path, metadata, config, files_data);
+        } else {
+            handle_folder_entry(file_name, relative_path, metadata, config, files_data);
+
+            if config.recursive {
+                collect_files_metadata(
+                    base_path,
+                    new_relative_path.as_path(),
+                    files_data,
+                    ignore_patterns,
+                    config,
+                )?;
             }
         }
     }
+
+    Ok(())
 }
 
 fn is_ignored(file_path: &str, ignore_patterns: &[Regex]) -> bool {
     ignore_patterns
         .iter()
         .any(|pattern| pattern.is_match(file_path))
 }
+
+fn get_dir_entry_and_metadata(
+    dir_entry_result: Result<std::fs::DirEntry, std::io::Error>,
+    config: &CollectFilesMetaConfig,
+) -> Result<Option<(std::fs::DirEntry, std::fs::Metadata)>, AppError> {
+    let dir = match dir_entry_result {
+        Ok(entry) => entry,
+        Err(e) => {
+            if config.skip_problematic_dir {
+                eprintln!("Error reading directory entry: {:?}", e);
+                return Ok(None);
+            } else {
+                return Err(AppError::FileError(e.to_string()));
+            }
+        }
+    };
+
+    let metadata = match dir.metadata() {
+        Ok(m) => m,
+        Err(e) => {
+            if config.skip_problematic_dir {
+                eprintln!("Error reading metadata for {:?}: {:?}", dir.path(), e);
+                return Ok(None);
+            } else {
+                return Err(AppError::FileError(e.to_string()));
+            }
+        }
+    };
+
+    Ok(Some((dir, metadata)))
+}
+
+fn handle_file_entry(
+    file_name: &String,
+    relative_path: &Path,
+    metadata: std::fs::Metadata,
+    config: &CollectFilesMetaConfig,
+    files_data: &mut Vec<FileInfo>,
+) {
+    print_processing_file(file_name);
+
+    if config.process_files {
+        let file_info =
+            convert_path_meta_to_file_info(file_name.to_string(), relative_path, metadata, false);
+        files_data.push(file_info);
+    }
+}
+
+fn handle_folder_entry(
+    file_name: String,
+    relative_path: &Path,
+    metadata: std::fs::Metadata,
+    config: &CollectFilesMetaConfig,
+    files_data: &mut Vec<FileInfo>,
+) {
+    if config.process_folders {
+        let file_info = convert_path_meta_to_file_info(
+            file_name.clone(),
+            relative_path,
+            metadata.clone(),
+            false,
+        );
+        files_data.push(file_info);
+    }
+}

src/files/file_info.rs

@@ -22,21 +22,14 @@ fn get_system_time_string(time: SystemTime) -> String {
 }
 
 pub fn convert_path_meta_to_file_info(
-    full_path: &Path,
-    relative_path: String,
+    file_name: String,
+    relative_path: &Path,
     file_meta: Metadata,
     is_root: bool,
 ) -> FileInfo {
-    let file_name = full_path
-        .file_name()
-        .map(|s| s.to_string_lossy().to_string())
-        .unwrap_or_else(|| "unknown".to_string());
-
-    // let relative_path = full_path.to_string_lossy().to_string();
-
     FileInfo {
         file_name,
-        relative_path,
+        relative_path: relative_path.to_string_lossy().to_string(),
         size: file_meta.len(),
         created_at: get_system_time_string(file_meta.created().unwrap_or(SystemTime::now())),
         modified_at: get_system_time_string(file_meta.modified().unwrap_or(SystemTime::now())),

src/main.rs

@@ -40,6 +40,14 @@ async fn main() {
                 print_app_error("Qdrant Error", e);
                 std::process::exit(1);
             }
+            AppError::JSONStringify(_) => {
+                print_app_error("JSON stringify error", e);
+                std::process::exit(1);
+            }
+            AppError::FileError(_) => {
+                print_app_error("File processing error", e);
+                std::process::exit(1);
+            }
             _ => {
                 print_app_error("Panic", e);
                 panic!("Unhandled error. \n Please post error stack trace on github issues page https://github.com/PerminovEugene/messy-folder-reorganizer-ai/issues");