parser: cargo fmt

parsing/src/autocomplete_hashmap.rs

@@ -3,81 +3,82 @@ use std::collections::HashSet;
 
 /// https://www.dotnetperls.com/sort-rust
 fn compare_len_reverse_alpha(a: &String, b: &String) -> Ordering {
-	match a.len().cmp(&b.len()) {
-		Ordering::Equal => b.cmp(a),
-		order => order,
-	}
+    match a.len().cmp(&b.len()) {
+        Ordering::Equal => b.cmp(a),
+        order => order,
+    }
 }
 
 /// Generates hashmap (well really a vector of tuple of strings that are then turned into a hashmap by phf)
 #[allow(dead_code)]
 pub fn compile_hashmap(data: Vec<String>) -> Vec<(String, String)> {
-	let mut seen = HashSet::new();
+    let mut seen = HashSet::new();
 
-	let tuple_list_1: Vec<(String, String)> = data
-		.iter()
-		.map(|e| e.to_string() + "(")
-		.flat_map(|func| all_possible_splits(func, &mut seen))
-		.collect();
+    let tuple_list_1: Vec<(String, String)> = data
+        .iter()
+        .map(|e| e.to_string() + "(")
+        .flat_map(|func| all_possible_splits(func, &mut seen))
+        .collect();
 
-	let keys: Vec<&String> = tuple_list_1.iter().map(|(a, _)| a).collect();
-	let mut output: Vec<(String, String)> = Vec::new();
-	let mut seen_3: HashSet<String> = HashSet::new();
+    let keys: Vec<&String> = tuple_list_1.iter().map(|(a, _)| a).collect();
+    let mut output: Vec<(String, String)> = Vec::new();
+    let mut seen_3: HashSet<String> = HashSet::new();
 
-	for (key, value) in tuple_list_1.iter() {
-		if seen_3.contains(key) {
-			continue;
-		}
+    for (key, value) in tuple_list_1.iter() {
+        if seen_3.contains(key) {
+            continue;
+        }
 
-		seen_3.insert(key.clone());
+        seen_3.insert(key.clone());
 
-		let count_keys = keys.iter().filter(|a| a == &&key).count();
+        let count_keys = keys.iter().filter(|a| a == &&key).count();
 
-		match count_keys.cmp(&1usize) {
-			Ordering::Less => {
-				panic!("Number of values for {key} is 0!");
-			}
-			Ordering::Greater => {
-				let mut multi_data = tuple_list_1
-					.iter()
-					.filter(|(a, _)| a == key)
-					.map(|(_, b)| b)
-					.collect::<Vec<&String>>();
-				multi_data.sort_unstable_by(|a, b| compare_len_reverse_alpha(a, b));
-				output.push((key.clone(), format!("Hint::Many(&{:?})", multi_data)));
-			}
-			Ordering::Equal => output.push((key.clone(), format!(r#"Hint::Single("{}")"#, value))),
-		}
-	}
+        match count_keys.cmp(&1usize) {
+            Ordering::Less => {
+                panic!("Number of values for {key} is 0!");
+            }
+            Ordering::Greater => {
+                let mut multi_data = tuple_list_1
+                    .iter()
+                    .filter(|(a, _)| a == key)
+                    .map(|(_, b)| b)
+                    .collect::<Vec<&String>>();
+                multi_data.sort_unstable_by(|a, b| compare_len_reverse_alpha(a, b));
+                output.push((key.clone(), format!("Hint::Many(&{:?})", multi_data)));
+            }
+            Ordering::Equal => output.push((key.clone(), format!(r#"Hint::Single("{}")"#, value))),
+        }
+    }
 
-	// sort
-	output.sort_unstable_by(|a, b| {
-		let new_a = format!(r#"("{}", {})"#, a.0, a.1);
-		let new_b = format!(r#"("{}", {})"#, b.0, b.1);
+    // sort
+    output.sort_unstable_by(|a, b| {
+        let new_a = format!(r#"("{}", {})"#, a.0, a.1);
+        let new_b = format!(r#"("{}", {})"#, b.0, b.1);
 
-		compare_len_reverse_alpha(&new_b, &new_a)
-	});
+        compare_len_reverse_alpha(&new_b, &new_a)
+    });
 
-	output
+    output
 }
 
 /// Returns a vector of all possible splitting combinations of a strings
 #[allow(dead_code)]
 fn all_possible_splits(
-	func: String, seen: &mut HashSet<(String, String)>,
+    func: String,
+    seen: &mut HashSet<(String, String)>,
 ) -> Vec<(String, String)> {
-	(1..func.len())
-		.map(|i| {
-			let (first, last) = func.split_at(i);
-			(first.to_string(), last.to_string())
-		})
-		.flat_map(|(first, last)| {
-			if seen.contains(&(first.clone(), last.clone())) {
-				return None;
-			}
-			seen.insert((first.to_string(), last.to_string()));
+    (1..func.len())
+        .map(|i| {
+            let (first, last) = func.split_at(i);
+            (first.to_string(), last.to_string())
+        })
+        .flat_map(|(first, last)| {
+            if seen.contains(&(first.clone(), last.clone())) {
+                return None;
+            }
+            seen.insert((first.to_string(), last.to_string()));
 
-			Some((first, last))
-		})
-		.collect::<Vec<(String, String)>>()
+            Some((first, last))
+        })
+        .collect::<Vec<(String, String)>>()
 }