feat(wipe): add support for wiping terraform folders

Author: mihai-dinculescu

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.3.3"
 edition = "2024"
 license = "MIT"
 authors = ["Mihai Dinculescu <mihai.dinculescu@outlook.com>"]
-description = "recursively wipe target and node_modules folders"
+description = "Cargo subcommand that recursively finds and optionally wipes all \"target\" (Rust), \"node_modules\" (Node), or \".terraform\" (Terraform) folders that are found in the current path."
 keywords = ["cli", "cargo", "wipe", "target", "node_modules"]
 categories = ["command-line-interface", "command-line-utilities"]
 readme = "README.md"

README.md

@@ -5,7 +5,8 @@
 [![codecov][codecov_badge]][codecov]
 [![license][license_badge]][license]
 [![Crates.io][crates_installs_badge]][crates]\
-Cargo subcommand that recursively finds and optionally wipes all "target" or "node_modules" folders that are found in the current path.
+Cargo subcommand that recursively finds and optionally wipes all "target" (Rust), 
+"node_modules" (Node), or ".terraform" (Terraform) folders that are found in the current path.
 
 ## Usage
 

src/command.rs

@@ -6,8 +6,9 @@ use clap::{Parser, ValueEnum, arg, command};
 #[derive(Debug, Parser)]
 #[command(name = "cargo", bin_name = "cargo")]
 pub enum Command {
-    /// Recursively finds and optionally wipes all "target" (Rust) or
-    /// "node_modules" (Node) folders that are found in the current path.
+    /// Recursively finds and optionally wipes all "target" (Rust),
+    /// "node_modules" (Node), or ".terraform" (Terraform) folders that
+    /// are found in the current path.
     /// Add the `-w` flag to wipe all folders found. USE WITH CAUTION!
     Wipe(Args),
 }
@@ -33,12 +34,14 @@ pub struct Args {
 pub enum LanguageEnum {
     Node,
     Rust,
+    Terraform,
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum DirectoryEnum {
     NodeModules,
     Target,
+    Terraform,
 }
 
 impl str::FromStr for LanguageEnum {
@@ -48,9 +51,10 @@ impl str::FromStr for LanguageEnum {
         match value.to_lowercase().trim() {
             "node" => Ok(LanguageEnum::Node),
             "rust" => Ok(LanguageEnum::Rust),
+            "terraform" => Ok(LanguageEnum::Terraform),
             _ => Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
-                "Valid options are: node | rust",
+                "Valid options are: node | rust | terraform",
             )),
         }
     }
@@ -61,6 +65,7 @@ impl fmt::Display for LanguageEnum {
         match self {
             LanguageEnum::Node => write!(f, "node"),
             LanguageEnum::Rust => write!(f, "rust"),
+            LanguageEnum::Terraform => write!(f, "terraform"),
         }
     }
 }
@@ -70,6 +75,7 @@ impl From<LanguageEnum> for DirectoryEnum {
         match language {
             LanguageEnum::Node => DirectoryEnum::NodeModules,
             LanguageEnum::Rust => DirectoryEnum::Target,
+            LanguageEnum::Terraform => DirectoryEnum::Terraform,
         }
     }
 }
@@ -79,6 +85,7 @@ impl From<&LanguageEnum> for DirectoryEnum {
         match language {
             LanguageEnum::Node => DirectoryEnum::NodeModules,
             LanguageEnum::Rust => DirectoryEnum::Target,
+            LanguageEnum::Terraform => DirectoryEnum::Terraform,
         }
     }
 }
@@ -88,6 +95,7 @@ impl fmt::Display for DirectoryEnum {
         match self {
             DirectoryEnum::NodeModules => write!(f, "node_modules"),
             DirectoryEnum::Target => write!(f, "target"),
+            DirectoryEnum::Terraform => write!(f, ".terraform"),
         }
     }
 }
@@ -103,6 +111,7 @@ mod tests {
     #[rstest]
     #[case("node", LanguageEnum::Node)]
     #[case("rust", LanguageEnum::Rust)]
+    #[case("terraform", LanguageEnum::Terraform)]
     #[case("RUST", LanguageEnum::Rust)]
     #[case("ruSt ", LanguageEnum::Rust)]
     fn language_string_to_enum(#[case] language_string: &str, #[case] language_enum: LanguageEnum) {
@@ -120,19 +129,24 @@ mod tests {
         let err = result.err().unwrap();
 
         assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(err.to_string(), "Valid options are: node | rust");
+        assert_eq!(
+            err.to_string(),
+            "Valid options are: node | rust | terraform"
+        );
     }
 
     #[rstest]
     #[case(LanguageEnum::Node, "node")]
     #[case(LanguageEnum::Rust, "rust")]
+    #[case(LanguageEnum::Terraform, "terraform")]
     fn language_enum_to_string(#[case] language_enum: LanguageEnum, #[case] language_string: &str) {
         assert_eq!(language_enum.to_string(), language_string);
     }
 
     #[rstest]
     #[case(LanguageEnum::Node, DirectoryEnum::NodeModules)]
     #[case(LanguageEnum::Rust, DirectoryEnum::Target)]
+    #[case(LanguageEnum::Terraform, DirectoryEnum::Terraform)]
     fn language_enum_to_directory_enum(
         #[case] language_enum: LanguageEnum,
         #[case] expected_directory_enum: DirectoryEnum,
@@ -144,6 +158,7 @@ mod tests {
     #[rstest]
     #[case(DirectoryEnum::NodeModules, "node_modules")]
     #[case(DirectoryEnum::Target, "target")]
+    #[case(DirectoryEnum::Terraform, ".terraform")]
     fn directory_enum_to_string(
         #[case] directory_enum: DirectoryEnum,
         #[case] directory_string: &str,

src/tests/helpers/test_run.rs

@@ -47,7 +47,7 @@ impl TestRun {
         run.generate_hits(language, hits_count);
         run.generate_ignores(language, ignores_count);
         run.generate_no_hits();
-        run.generate_opposite(language);
+        run.generate_different_language_hits(language);
         run.generate_invalid(language);
         run.generate_partial(language);
 
@@ -107,15 +107,18 @@ impl TestRun {
         }
     }
 
-    fn generate_opposite(&mut self, language: &LanguageEnum) {
-        let opposite = if matches!(language, LanguageEnum::Node) {
-            "target"
+    fn generate_different_language_hits(&mut self, language: &LanguageEnum) {
+        let different_language = if language == &LanguageEnum::Node {
+            DirectoryEnum::Target.to_string()
         } else {
-            "node_modules"
+            DirectoryEnum::NodeModules.to_string()
         };
 
         let name = TestRun::generate_folder_name(&mut self.rng);
-        let path = self.path.join(Path::new(&name)).join(Path::new(opposite));
+        let path = self
+            .path
+            .join(Path::new(&name))
+            .join(Path::new(&different_language));
 
         std::fs::create_dir_all(&path).unwrap();
 

src/tests/wipe.rs

@@ -15,6 +15,8 @@ use crate::writer::{SPACING_FILES, SPACING_SIZE};
 #[case(LanguageEnum::Node, true)]
 #[case(LanguageEnum::Rust, false)]
 #[case(LanguageEnum::Rust, true)]
+#[case(LanguageEnum::Terraform, false)]
+#[case(LanguageEnum::Terraform, true)]
 fn run_with_hits(#[case] language: LanguageEnum, #[case] wipe: bool) {
     let test_run = TestRun::new(&language, 3, 0);
     let directory: DirectoryEnum = (&language).into();
@@ -94,6 +96,8 @@ fn run_with_hits(#[case] language: LanguageEnum, #[case] wipe: bool) {
 #[case(LanguageEnum::Node, true)]
 #[case(LanguageEnum::Rust, false)]
 #[case(LanguageEnum::Rust, true)]
+#[case(LanguageEnum::Terraform, false)]
+#[case(LanguageEnum::Terraform, true)]
 fn run_no_hits(#[case] language: LanguageEnum, #[case] wipe: bool) {
     let test_run = TestRun::new(&language, 0, 0);
 
@@ -146,6 +150,8 @@ fn run_no_hits(#[case] language: LanguageEnum, #[case] wipe: bool) {
 #[case(LanguageEnum::Node, true)]
 #[case(LanguageEnum::Rust, false)]
 #[case(LanguageEnum::Rust, true)]
+#[case(LanguageEnum::Terraform, false)]
+#[case(LanguageEnum::Terraform, true)]
 fn run_with_ignores(#[case] language: LanguageEnum, #[case] wipe: bool) {
     let test_run = TestRun::new(&language, 3, 3);
 

src/tests/wipe_permissions.rs

@@ -15,6 +15,8 @@ mod wipe_permissions_tests {
     #[case(LanguageEnum::Node, true)]
     #[case(LanguageEnum::Rust, false)]
     #[case(LanguageEnum::Rust, true)]
+    #[case(LanguageEnum::Terraform, false)]
+    #[case(LanguageEnum::Terraform, true)]
     fn test_with_readonly_folders(#[case] language: LanguageEnum, #[case] wipe: bool) {
         use std::fs;
         use std::os::unix::fs::PermissionsExt;

src/wipe_params.rs

@@ -40,6 +40,9 @@ mod tests {
     #[case(Args { language: LanguageEnum::Rust, wipe: false, ignores: Vec::new() })]
     #[case(Args { language: LanguageEnum::Rust, wipe: true, ignores: Vec::new() })]
     #[case(Args { language: LanguageEnum::Rust, wipe: true, ignores: vec![PathBuf::from("example/path")] })]
+    #[case(Args { language: LanguageEnum::Terraform, wipe: false, ignores: Vec::new() })]
+    #[case(Args { language: LanguageEnum::Terraform, wipe: true, ignores: Vec::new() })]
+    #[case(Args { language: LanguageEnum::Terraform, wipe: true, ignores: vec![PathBuf::from("example/path")] })]
     fn test_wipe_params(#[case] args: Args) {
         let params = WipeParams::new(&args).unwrap();