did_you_mean without dependency (#2610)

crates/nu-protocol/Cargo.toml

@@ -20,7 +20,6 @@ getset = "0.1.1"
 indexmap = {version = "1.6.0", features = ["serde-1"]}
 itertools = "0.9.0"
 log = "0.4.11"
-natural = "0.5.0"
 nu-errors = {path = "../nu-errors", version = "0.20.0"}
 nu-source = {path = "../nu-source", version = "0.20.0"}
 num-bigint = {version = "0.3.0", features = ["serde"]}

crates/nu-protocol/src/lib.rs

@@ -18,8 +18,9 @@ pub use crate::signature::{NamedType, PositionalType, Signature};
 pub use crate::syntax_shape::SyntaxShape;
 pub use crate::type_name::{PrettyType, ShellTypeName, SpannedTypeName};
 pub use crate::type_shape::{Row as RowType, Type};
-pub use crate::value::column_path::{did_you_mean, ColumnPath, PathMember, UnspannedPathMember};
+pub use crate::value::column_path::{ColumnPath, PathMember, UnspannedPathMember};
 pub use crate::value::dict::{Dictionary, TaggedDictBuilder};
+pub use crate::value::did_you_mean::did_you_mean;
 pub use crate::value::evaluate::Scope;
 pub use crate::value::primitive::Primitive;
 pub use crate::value::primitive::{format_date, format_duration, format_primitive};

crates/nu-protocol/src/value.rs

@@ -2,6 +2,7 @@ pub mod column_path;
 mod convert;
 mod debug;
 pub mod dict;
+pub mod did_you_mean;
 pub mod evaluate;
 pub mod iter;
 pub mod primitive;

crates/nu-protocol/src/value/column_path.rs

@@ -1,4 +1,3 @@
-use crate::Value;
 use derive_new::new;
 use getset::Getters;
 use nu_source::{b, span_for_spanned_list, DebugDocBuilder, HasFallibleSpan, PrettyDebug, Span};
@@ -112,65 +111,3 @@ impl PathMember {
         }
     }
 }
-
-/// Prepares a list of "sounds like" matches (using edit distance) for the string you're trying to find
-pub fn did_you_mean(obj_source: &Value, field_tried: String) -> Option<Vec<String>> {
-    let possibilities = obj_source.data_descriptors();
-
-    let mut possible_matches: Vec<_> = possibilities
-        .into_iter()
-        .map(|word| {
-            let edit_distance = natural::distance::levenshtein_distance(&word, &field_tried);
-            (edit_distance, word)
-        })
-        .collect();
-
-    if !possible_matches.is_empty() {
-        possible_matches.sort();
-        let words_matched: Vec<String> = possible_matches.into_iter().map(|m| m.1).collect();
-        Some(words_matched)
-    } else {
-        None
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::UntaggedValue;
-    use indexmap::indexmap;
-    use nu_source::Tag;
-
-    #[test]
-    fn did_you_mean_returns_possible_column_matches() {
-        let value = UntaggedValue::row(indexmap! {
-           "dog".to_string() => UntaggedValue::int(1).into(),
-           "cat".to_string() => UntaggedValue::int(1).into(),
-           "alt".to_string() => UntaggedValue::int(1).into(),
-        });
-
-        let source = Value {
-            tag: Tag::unknown(),
-            value,
-        };
-
-        assert_eq!(
-            Some(vec![
-                "cat".to_string(),
-                "alt".to_string(),
-                "dog".to_string()
-            ]),
-            did_you_mean(&source, "hat".to_string())
-        )
-    }
-
-    #[test]
-    fn did_you_mean_returns_no_matches_when_empty() {
-        let empty_source = Value {
-            tag: Tag::unknown(),
-            value: UntaggedValue::row(indexmap! {}),
-        };
-
-        assert_eq!(None, did_you_mean(&empty_source, "hat".to_string()))
-    }
-}

crates/nu-protocol/src/value/did_you_mean.rs

@@ -0,0 +1,94 @@
+use crate::Value;
+use std::cmp;
+
+/// Prepares a list of "sounds like" matches (using edit distance) for the string you're trying to find
+pub fn did_you_mean(obj_source: &Value, field_tried: String) -> Option<Vec<String>> {
+    let possibilities = obj_source.data_descriptors();
+
+    let mut possible_matches: Vec<_> = possibilities
+        .into_iter()
+        .map(|word| {
+            let edit_distance = levenshtein_distance(&word, &field_tried);
+            (edit_distance, word)
+        })
+        .collect();
+
+    if !possible_matches.is_empty() {
+        possible_matches.sort();
+        let words_matched: Vec<String> = possible_matches.into_iter().map(|m| m.1).collect();
+        Some(words_matched)
+    } else {
+        None
+    }
+}
+
+/// Borrowed from https://crates.io/crates/natural
+fn levenshtein_distance(str1: &str, str2: &str) -> usize {
+    let n = str1.len();
+    let m = str2.len();
+
+    let mut current: Vec<usize> = (0..n + 1).collect();
+    let a_vec: Vec<char> = str1.chars().collect();
+    let b_vec: Vec<char> = str2.chars().collect();
+
+    for i in 1..m + 1 {
+        let previous = current;
+        current = vec![0; n + 1];
+        current[0] = i;
+        for j in 1..n + 1 {
+            let add = previous[j] + 1;
+            let delete = current[j - 1] + 1;
+            let mut change = previous[j - 1];
+            if a_vec[j - 1] != b_vec[i - 1] {
+                change += 1
+            }
+            current[j] = min3(add, delete, change);
+        }
+    }
+    current[n]
+}
+
+fn min3<T: Ord>(a: T, b: T, c: T) -> T {
+    cmp::min(a, cmp::min(b, c))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::UntaggedValue;
+    use indexmap::indexmap;
+    use nu_source::Tag;
+
+    #[test]
+    fn did_you_mean_returns_possible_column_matches() {
+        let value = UntaggedValue::row(indexmap! {
+           "dog".to_string() => UntaggedValue::int(1).into(),
+           "cat".to_string() => UntaggedValue::int(1).into(),
+           "alt".to_string() => UntaggedValue::int(1).into(),
+        });
+
+        let source = Value {
+            tag: Tag::unknown(),
+            value,
+        };
+
+        assert_eq!(
+            Some(vec![
+                "cat".to_string(),
+                "alt".to_string(),
+                "dog".to_string()
+            ]),
+            did_you_mean(&source, "hat".to_string())
+        )
+    }
+
+    #[test]
+    fn did_you_mean_returns_no_matches_when_empty() {
+        let empty_source = Value {
+            tag: Tag::unknown(),
+            value: UntaggedValue::row(indexmap! {}),
+        };
+
+        assert_eq!(None, did_you_mean(&empty_source, "hat".to_string()))
+    }
+}