asklyphe/asklyphe-frontend/src/bangs.rs

use tracing::{debug, error};
use once_cell::sync::Lazy;
use std::collections::BTreeMap;
use url_encoded_data;

pub static BANG_PREFIX: &str = "!";

#[derive(Debug)]
struct Bang<'a> {
	pub url: &'a str,
	pub keys: &'a [&'a str]
}

impl<'a> Bang<'_> {
	fn new(url: &'a str, keys: &'a [&'a str]) -> Bang<'a> {
		Bang {url, keys}
	}
}

static BUILTIN_BANGS: Lazy<BTreeMap<&str, Bang>> = Lazy::new(|| {
	let mut bangs = BTreeMap::new();
	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("Wikipedia", Bang::new("https://wikipedia.org/w/index.php?search={}", &["w", "wiki", "wikipedia"] as &[&str]));
	bangs
});

#[derive(Debug, Clone)]
struct BangLoc<'b> {
	pub url: &'b str,
	pub start_idx: usize,
	pub len: usize
}

impl<'b> BangLoc<'_> {
	fn new(url: &'b str, start_idx: usize, len: usize) -> BangLoc<'b> {
		BangLoc {url, start_idx, len}
	}
}

#[derive(Debug)]
pub struct BangRedirect {
	pub url: String
}

pub fn do_bangs_or_whatever(query: &String) -> Option<BangRedirect> {
	error!("Hello, World!");
	if !query.contains(BANG_PREFIX) {
		return None;
	}
	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() {
			true
		} else {
			false
		}
	}).map(|(bang_start_idx, _)| {
		let rest = query.get(bang_start_idx + 1..query.len()).unwrap();
		BUILTIN_BANGS.iter().map(|(_, bang)| {
			let key = bang.keys.iter()
				.filter(|key| rest.starts_with(**key))
				.filter(
					|key| rest.chars()
					.nth(key.len())
					.unwrap_or(' ')
					.is_whitespace())
				.max_by(|a, b| a.len().cmp(&b.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())
	.collect::<Vec<_>>();
	debug!("Result: {:?}", bangs);

	let bang = bangs.first()?;
	let end_idx = bang.start_idx + 1 + bang.len;
	debug!("Initial query: \"{}\"", query);
	let query_split = query.split_once(query.get(bang.start_idx..end_idx).unwrap()).unwrap();
	debug!("Split query: {:?}", query_split);
	let query_trimmed = format!("{}{}", query_split.0, query_split.1);
	debug!("Trimmed query: \"{}\"", query_trimmed);
	let query_encoded = url_encoded_data::stringify(&[("", query_trimmed.as_str())]);
	let query_encoded = query_encoded.get(1..query_encoded.len()).unwrap().to_owned();
	debug!("Encoded query: {:?}", query_encoded);

	let bang_url_split = bang.url.split_once("{}").unwrap();
	debug!("Split bang URL: {:?}", bang_url_split);
	let bang_url = format!(
		"{}{}{}",
		bang_url_split.0,
		query_encoded,
		bang_url_split.1
	);
	debug!("Final URL: \"{}\"", bang_url);
	Some(BangRedirect{url: bang_url})
}