spaces to follow at least a little code style :(

asklyphe-frontend/src/bangs.rs

@@ -7,100 +7,100 @@ pub static BANG_PREFIX: &str = "!";
 
 #[derive(Debug)]
 struct Bang<'a> {
-	pub url: &'a str,
+    pub url: &'a str,
-	pub keys: &'a [&'a str]
+    pub keys: &'a [&'a str]
 }
 
 impl<'a> Bang<'_> {
-	fn new(url: &'a str, keys: &'a [&'a str]) -> Bang<'a> {
+    fn new(url: &'a str, keys: &'a [&'a str]) -> Bang<'a> {
-		Bang {url, keys}
+        Bang {url, keys}
-	}
+    }
 }
 
 static BUILTIN_BANGS: Lazy<BTreeMap<&str, Bang>> = Lazy::new(|| {
-	let mut bangs = BTreeMap::new();
+    let mut bangs = BTreeMap::new();
-	bangs.insert("Google", Bang::new("https://google.com/search?q={}", &["g", "google"] as &[&str]));
+    bangs.insert("Google", Bang::new("https://google.com/search?q={}", &["g", "google"] as &[&str]));
 
-	bangs.insert("DuckDuckGo", Bang::new("https://duckduckgo.com/?q={}", &["d", "ddg", "duckduckgo"] as &[&str]));
+    bangs.insert("DuckDuckGo", Bang::new("https://duckduckgo.com/?q={}", &["d", "ddg", "duckduckgo"] as &[&str]));
 
-	bangs.insert("Wikipedia", Bang::new("https://wikipedia.org/w/index.php?search={}", &["w", "wiki", "wikipedia"] as &[&str]));
+    bangs.insert("Wikipedia", Bang::new("https://wikipedia.org/w/index.php?search={}", &["w", "wiki", "wikipedia"] as &[&str]));
-	bangs
+    bangs
 });
 
 #[derive(Debug, Clone)]
 struct BangLoc<'b> {
-	pub url: &'b str,
+    pub url: &'b str,
-	pub start_idx: usize,
+    pub start_idx: usize,
-	pub len: usize
+    pub len: usize
 }
 
 impl<'b> BangLoc<'_> {
-	fn new(url: &'b str, start_idx: usize, len: usize) -> BangLoc<'b> {
+    fn new(url: &'b str, start_idx: usize, len: usize) -> BangLoc<'b> {
-		BangLoc {url, start_idx, len}
+        BangLoc {url, start_idx, len}
-	}
+    }
 }
 
 pub fn redirect_bang(query: &String) -> Option<String> {
-	if !query.contains(BANG_PREFIX) {
+    if !query.contains(BANG_PREFIX) {
-		return None;
+        return None;
-	}
+    }
-	let bangs = query.match_indices(BANG_PREFIX).filter(|(bang_start_idx, _)| {
+    let bangs = query.match_indices(BANG_PREFIX).filter(|(bang_start_idx, _)| {
-		if *bang_start_idx == 0 || query.chars().nth(*bang_start_idx - 1).unwrap().is_whitespace() {
+        if *bang_start_idx == 0 || query.chars().nth(*bang_start_idx - 1).unwrap().is_whitespace() {
-			true
+            true
-		} else {
+        } else {
-			false
+            false
-		}
+        }
-	}).map(|(bang_start_idx, _)| {
+    }).map(|(bang_start_idx, _)| {
-		let rest = query.get(bang_start_idx + 1..query.len()).unwrap();
+        let rest = query.get(bang_start_idx + 1..query.len()).unwrap();
-		BUILTIN_BANGS.iter().map(|(_, bang)| {
+        BUILTIN_BANGS.iter().map(|(_, bang)| {
-			let key = bang.keys.iter()
+            let key = bang.keys.iter()
-				.filter(|key| rest.starts_with(**key))
+                .filter(|key| rest.starts_with(**key))
-				.filter(
+                .filter(
-					|key| rest.chars()
+                    |key| rest.chars()
-					.nth(key.len())
+                    .nth(key.len())
-					.unwrap_or(' ')
+                    .unwrap_or(' ')
-					.is_whitespace())
+                    .is_whitespace())
-				.max_by(|a, b| a.len().cmp(&b.len()))?;
+                .max_by(|a, b| a.len().cmp(&b.len()))?;
-			Some(BangLoc::new(bang.url, bang_start_idx, key.len()))
+            Some(BangLoc::new(bang.url, bang_start_idx, key.len()))
-		}).filter(|bang| bang.is_some()).map(|bang| bang.unwrap()).next()
+        }).filter(|bang| bang.is_some()).map(|bang| bang.unwrap()).next()
-	}).filter(|bang| bang.is_some())
+    }).filter(|bang| bang.is_some())
-	.map(|bang| bang.unwrap())
+    .map(|bang| bang.unwrap())
-	.collect::<Vec<_>>();
+    .collect::<Vec<_>>();
 
 
-	let bang = bangs.first()?;
+    let bang = bangs.first()?;
-	let end_idx = {
+    let end_idx = {
-		let mut end_idx = bang.start_idx + 1 + bang.len;
+        let mut end_idx = bang.start_idx + 1 + bang.len;
-		if end_idx < query.len() {
+        if end_idx < query.len() {
-			end_idx += 1;
+            end_idx += 1;
-		}
+        }
-		end_idx
+        end_idx
-	};
+    };
 
-	let start_idx = if end_idx == query.len() && bang.start_idx > 0 {
+    let start_idx = if end_idx == query.len() && bang.start_idx > 0 {
-		bang.start_idx - 1
+        bang.start_idx - 1
-	} else {
+    } else {
-		bang.start_idx
+        bang.start_idx
-	};
+    };
 
 
-	let query_split = query.split_once(query.get(start_idx..end_idx).unwrap()).unwrap();
+    let query_split = query.split_once(query.get(start_idx..end_idx).unwrap()).unwrap();
 
-	let query_trimmed = format!("{}{}", query_split.0, query_split.1);
+    let query_trimmed = format!("{}{}", query_split.0, query_split.1);
 
-	// A hack to get URL escaping without using a proper URL layout, hopefully has no other issues apart from prepending '=' to the string
+    // A hack to get URL escaping without using a proper URL layout, hopefully has no other issues apart from prepending '=' to the string
-	let query_encoded = url_encoded_data::stringify(&[("", query_trimmed.as_str())]);
+    let query_encoded = url_encoded_data::stringify(&[("", query_trimmed.as_str())]);
-	let query_encoded = query_encoded.get(1..query_encoded.len()).unwrap().to_owned();
+    let query_encoded = query_encoded.get(1..query_encoded.len()).unwrap().to_owned();
 
 
-	let bang_url_split = bang.url.split_once("{}").unwrap();
+    let bang_url_split = bang.url.split_once("{}").unwrap();
 
-	let bang_url = format!(
+    let bang_url = format!(
-		"{}{}{}",
+        "{}{}{}",
-		bang_url_split.0,
+        bang_url_split.0,
-		query_encoded,
+        query_encoded,
-		bang_url_split.1
+        bang_url_split.1
-	);
+    );
 
-	Some(bang_url)
+    Some(bang_url)
 }