refactor: separate the wipe logic from the writer

Author: mihai-dinculescu

src/dir_helpers.rs

@@ -3,7 +3,9 @@ use number_prefix::NumberPrefix;
 use std::path::PathBuf;
 use std::{fs, io};
 
-use crate::command::DirectoryEnum;
+use crate::command::{DirectoryEnum, LanguageEnum};
+
+pub type PathsResult = io::Result<Vec<Result<String, io::Error>>>;
 
 #[derive(Debug, Copy, Clone)]
 pub struct DirInfo {
@@ -38,90 +40,90 @@ impl DirInfo {
             NumberPrefix::Standalone(bytes) => format!("{bytes} bytes"),
         }
     }
-}
-
-fn is_valid_target(path: PathBuf, directory: &DirectoryEnum) -> bool {
-    if directory == &DirectoryEnum::Target {
-        let file_path = path.join(".rustc_info.json");
-        return file_path.exists();
-    }
 
-    true
-}
+    fn is_valid_target(path: PathBuf, directory: &DirectoryEnum) -> bool {
+        if directory == &DirectoryEnum::Target {
+            let file_path = path.join(".rustc_info.json");
+            return file_path.exists();
+        }
 
-pub type PathsResult = io::Result<Vec<Result<String, io::Error>>>;
+        true
+    }
 
-pub fn get_paths_to_delete(path: impl Into<PathBuf>, directory: &DirectoryEnum) -> PathsResult {
-    fn walk(dir: io::Result<fs::ReadDir>, directory: &DirectoryEnum) -> PathsResult {
-        let mut dir = match dir {
-            Ok(dir) => dir,
-            Err(e) => {
-                return Ok(vec![Err(e)]);
-            }
-        };
+    pub fn get_paths_to_delete(path: impl Into<PathBuf>, language: &LanguageEnum) -> PathsResult {
+        let directory: DirectoryEnum = language.clone().into();
 
-        dir.try_fold(
-            Vec::new(),
-            |mut acc: Vec<Result<String, io::Error>>, file| {
-                let file = file?;
+        fn walk(dir: io::Result<fs::ReadDir>, directory: &DirectoryEnum) -> PathsResult {
+            let mut dir = match dir {
+                Ok(dir) => dir,
+                Err(e) => {
+                    return Ok(vec![Err(e)]);
+                }
+            };
 
-                let size = match file.metadata() {
-                    Ok(data) if data.is_dir() => {
-                        if file.file_name() == directory.to_string()[..] {
-                            if is_valid_target(file.path(), directory) {
-                                acc.push(Ok(file.path().display().to_string()));
+            dir.try_fold(
+                Vec::new(),
+                |mut acc: Vec<Result<String, io::Error>>, file| {
+                    let file = file?;
+
+                    let size = match file.metadata() {
+                        Ok(data) if data.is_dir() => {
+                            if file.file_name() == directory.to_string()[..] {
+                                if DirInfo::is_valid_target(file.path(), directory) {
+                                    acc.push(Ok(file.path().display().to_string()));
+                                }
+                            } else {
+                                acc.append(&mut walk(fs::read_dir(file.path()), directory)?);
                             }
-                        } else {
-                            acc.append(&mut walk(fs::read_dir(file.path()), directory)?);
+                            acc
                         }
-                        acc
-                    }
-                    _ => acc,
-                };
+                        _ => acc,
+                    };
+
+                    Ok(size)
+                },
+            )
+        }
 
-                Ok(size)
-            },
-        )
+        walk(fs::read_dir(path.into()), &directory)
     }
 
-    walk(fs::read_dir(path.into()), directory)
-}
+    pub fn dir_size(path: impl Into<PathBuf>) -> io::Result<DirInfo> {
+        fn walk(dir: io::Result<fs::ReadDir>) -> io::Result<DirInfo> {
+            let mut dir = match dir {
+                Ok(dir) => dir,
+                Err(_) => {
+                    // Return empty stats for unreadable directories instead of failing
+                    return Ok(DirInfo::new(0, 0, 0));
+                }
+            };
 
-pub fn dir_size(path: impl Into<PathBuf>) -> io::Result<DirInfo> {
-    fn walk(dir: io::Result<fs::ReadDir>) -> io::Result<DirInfo> {
-        let mut dir = match dir {
-            Ok(dir) => dir,
-            Err(_) => {
-                // Return empty stats for unreadable directories instead of failing
-                return Ok(DirInfo::new(0, 0, 0));
-            }
-        };
+            dir.try_fold(DirInfo::new(0, 0, 0), |acc, file| {
+                let file = file?;
 
-        dir.try_fold(DirInfo::new(0, 0, 0), |acc, file| {
-            let file = file?;
+                let info = match file.metadata() {
+                    // For directories: count 1 directory + recursively count its contents
+                    Ok(data) if data.is_dir() => {
+                        let sub_info = walk(fs::read_dir(file.path()))?;
+                        DirInfo::new(1 + sub_info.dir_count, sub_info.file_count, sub_info.size)
+                    }
+                    // For files: count 1 file and its size in bytes
+                    Ok(data) => DirInfo::new(0, 1, data.len() as usize),
+                    // Skip entries we can't read metadata for
+                    _ => DirInfo::new(0, 0, 0),
+                };
 
-            let info = match file.metadata() {
-                // For directories: count 1 directory + recursively count its contents
-                Ok(data) if data.is_dir() => {
-                    let sub_info = walk(fs::read_dir(file.path()))?;
-                    DirInfo::new(1 + sub_info.dir_count, sub_info.file_count, sub_info.size)
-                }
-                // For files: count 1 file and its size in bytes
-                Ok(data) => DirInfo::new(0, 1, data.len() as usize),
-                // Skip entries we can't read metadata for
-                _ => DirInfo::new(0, 0, 0),
-            };
+                // Accumulate counts from this entry with running totals
+                Ok(DirInfo::new(
+                    acc.dir_count + info.dir_count,
+                    acc.file_count + info.file_count,
+                    acc.size + info.size,
+                ))
+            })
+        }
 
-            // Accumulate counts from this entry with running totals
-            Ok(DirInfo::new(
-                acc.dir_count + info.dir_count,
-                acc.file_count + info.file_count,
-                acc.size + info.size,
-            ))
-        })
+        walk(fs::read_dir(path.into()))
     }
-
-    walk(fs::read_dir(path.into()))
 }
 
 #[cfg(test)]

src/main.rs

@@ -5,11 +5,12 @@ use clap::Parser;
 pub mod command;
 pub mod dir_helpers;
 pub mod wipe;
+pub mod wipe_params;
+pub mod writer;
 
-use crate::{
-    command::Command,
-    wipe::{Wipe, WipeParams},
-};
+use crate::command::Command;
+use crate::wipe::Wipe;
+use crate::wipe_params::WipeParams;
 
 #[cfg(test)]
 mod tests;

src/tests/wipe.rs

@@ -1,11 +1,13 @@
 use parameterized::parameterized;
 use std::path::PathBuf;
 use std::{io::Cursor, println};
-use yansi::Paint;
+use yansi::Paint as _;
 
 use crate::command::LanguageEnum;
 use crate::tests::helpers::test_run::TestRun;
-use crate::wipe::{SPACING_FILES, SPACING_SIZE, Wipe, WipeParams};
+use crate::wipe::Wipe;
+use crate::wipe_params::WipeParams;
+use crate::writer::{SPACING_FILES, SPACING_SIZE};
 
 #[parameterized(
     language = {

src/tests/wipe_params.rs

@@ -2,7 +2,7 @@ use parameterized::parameterized;
 use std::path::PathBuf;
 
 use crate::command::{Args, LanguageEnum};
-use crate::wipe::WipeParams;
+use crate::wipe_params::WipeParams;
 
 #[parameterized(
     args = {