refactor: finding similar strings

Author: ankddev

Diff for: src/commands.rs

@@ -1,5 +1,4 @@
 use rayon::prelude::*;
-use similar_string;
 use std::{env, fs, process};
 
 use crate::models::*;
@@ -58,17 +57,7 @@ pub fn get(args: &GetArgs) {
             // Check if we need to search for similar environment variables
             if !args.no_similar_names {
                 // Check for similar variables, if user made a mistake
-                let similar_names = env::vars()
-                    .collect::<Vec<_>>()
-                    .into_par_iter()
-                    .map(|(name, _)| name)
-                    .filter(|name| {
-                        similar_string::compare_similarity(
-                            args.key.to_lowercase(),
-                            name.to_lowercase(),
-                        ) > 0.6
-                    })
-                    .collect::<Vec<_>>();
+                let similar_names = find_similar_string(args.key.clone(), env::vars().map(|(key, _)| key).collect(), 0.6);
                 if !similar_names.is_empty() {
                     eprintln!("Did you mean:");
                     for name in similar_names {

Diff for: src/utils.rs

@@ -1,4 +1,5 @@
 use colored::Colorize;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use std::process;
 use subprocess::Exec;
 
@@ -36,3 +37,82 @@ pub fn warning(text: &str, exit_on_warning: bool) {
         process::exit(1);
     }
 }
+
+/// Returns vector of string that are similar by threshold to given string in given vector
+pub fn find_similar_string(string: String, strings: Vec<String>, threshold:f64) -> Vec<String> {
+    strings.par_iter()
+        .filter(|name| {
+            similar_string::compare_similarity(
+                string.to_lowercase(),
+                name.to_lowercase(),
+            ) > threshold
+        })
+        .map(|name| name.to_string())
+        .collect::<Vec<_>>()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_var_name_valid() {
+        let result = validate_var_name("VALID_NAME");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_validate_var_name_with_space() {
+        let result = validate_var_name("INVALID NAME");
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "Variable name cannot contain spaces");
+    }
+
+    #[test]
+    fn test_find_similar_string_exact_match() {
+        let strings = vec![
+            "PATH".to_string(),
+            "HOME".to_string(),
+            "USER".to_string()
+        ];
+        let result = find_similar_string("PATH".to_string(), strings, 0.8);
+        assert_eq!(result, vec!["PATH"]);
+    }
+
+    #[test]
+    fn test_find_similar_string_case_insensitive() {
+        let strings = vec![
+            "PATH".to_string(),
+            "HOME".to_string(),
+            "USER".to_string()
+        ];
+        let result = find_similar_string("path".to_string(), strings, 0.8);
+        assert_eq!(result, vec!["PATH"]);
+    }
+
+    #[test]
+    fn test_find_similar_string_no_match() {
+        let strings = vec![
+            "PATH".to_string(),
+            "HOME".to_string(),
+            "USER".to_string()
+        ];
+        let result = find_similar_string("XXXXXX".to_string(), strings, 0.8);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_find_similar_string_multiple_matches() {
+        let strings = vec![
+            "TEST".to_string(),
+            "TSET".to_string(),
+            "TEXT".to_string(),
+            "NONE".to_string()
+        ];
+        let result = find_similar_string("TEST".to_string(), strings, 0.5);
+        assert!(result.contains(&"TEST".to_string()));
+        assert!(result.contains(&"TEXT".to_string()));
+        assert!(result.contains(&"TSET".to_string()));
+        assert!(!result.contains(&"NONE".to_string()));
+    }
+}