diff --git a/build.rs b/build.rs index 8f95cba..6e8b3c8 100644 --- a/build.rs +++ b/build.rs @@ -48,7 +48,7 @@ fn generate_hashmap() { write!( &mut file, - "static COMPLETION_HASHMAP: phf::Map<&'static str, HintEnum> = {};", + "static COMPLETION_HASHMAP: phf::Map<&'static str, Hint> = {};", hashmap.build() ) .expect("Could not write to file"); diff --git a/src/autocomplete_helper.rs b/src/autocomplete_helper.rs index 6a83621..96fbcdf 100644 --- a/src/autocomplete_helper.rs +++ b/src/autocomplete_helper.rs @@ -34,7 +34,7 @@ pub fn compile_hashmap(data: Vec) -> Vec<(String, String)> { seen_3.insert(key.clone()); if keys.iter().filter(|a| a == &&key).count() == 1 { - output.push((key.clone(), format!(r#"HintEnum::Single("{}")"#, value))); + output.push((key.clone(), format!(r#"Hint::Single("{}")"#, value))); } else { let mut multi_data = tuple_list_1 .iter() @@ -42,7 +42,7 @@ pub fn compile_hashmap(data: Vec) -> Vec<(String, String)> { .map(|(_, b)| b) .collect::>(); multi_data.sort_unstable_by(|a, b| compare_len_reverse_alpha(a, b)); - output.push((key.clone(), format!("HintEnum::Many(&{:?})", multi_data))); + output.push((key.clone(), format!("Hint::Many(&{:?})", multi_data))); } } println!("Done! {:?}", start.elapsed()); @@ -80,15 +80,15 @@ mod tests { fn hashmap_gen_test() { let data = vec!["time", "text", "test"]; let expect = vec![ - ("t", r#"HintEnum::Many(&["ime(", "ext(", "est("])"#), - ("ti", r#"HintEnum::Single("me(")"#), - ("tim", r#"HintEnum::Single("e(")"#), - ("time", r#"HintEnum::Single("(")"#), - ("te", r#"HintEnum::Many(&["xt(", "st("])"#), - ("tex", r#"HintEnum::Single("t(")"#), - ("text", r#"HintEnum::Single("(")"#), - ("tes", r#"HintEnum::Single("t(")"#), - ("test", r#"HintEnum::Single("(")"#), + ("t", r#"Hint::Many(&["ime(", "ext(", "est("])"#), + ("ti", r#"Hint::Single("me(")"#), + ("tim", r#"Hint::Single("e(")"#), + ("time", r#"Hint::Single("(")"#), + ("te", r#"Hint::Many(&["xt(", "st("])"#), + ("tex", r#"Hint::Single("t(")"#), + ("text", r#"Hint::Single("(")"#), + ("tes", r#"Hint::Single("t(")"#), + ("test", r#"Hint::Single("(")"#), ]; assert_eq!( diff --git a/src/function.rs b/src/function.rs index a3d4724..bee2307 100644 --- a/src/function.rs +++ b/src/function.rs @@ -87,7 +87,7 @@ impl Default for FunctionEntry { impl FunctionEntry { /// Create autocomplete ui and handle user input pub fn auto_complete(&mut self, ui: &mut egui::Ui, i: i32) { - self.autocomplete.update(&self.raw_func_str); + self.autocomplete.update_string(&self.raw_func_str); self.autocomplete.ui(ui, i); let output_string = self.autocomplete.string.clone(); diff --git a/src/suggestions.rs b/src/suggestions.rs index e0d26c9..2344d3a 100644 --- a/src/suggestions.rs +++ b/src/suggestions.rs @@ -1,12 +1,12 @@ use crate::misc::chars_take; -pub const HINTENUM_EMPTY: HintEnum = HintEnum::Single("x^2"); -const HINTENUM_CLOSED_PARENS: HintEnum = HintEnum::Single(")"); +pub const HINT_EMPTY: Hint = Hint::Single("x^2"); +const HINT_CLOSED_PARENS: Hint = Hint::Single(")"); /// Generate a hint based on the input `input`, returns an `Option` -pub fn generate_hint<'a>(input: &str) -> &'a HintEnum<'a> { +pub fn generate_hint<'a>(input: &str) -> &'a Hint<'a> { if input.is_empty() { - return &HINTENUM_EMPTY; + return &HINT_EMPTY; } let chars: Vec = input.chars().collect::>(); @@ -20,7 +20,7 @@ pub fn generate_hint<'a>(input: &str) -> &'a HintEnum<'a> { }); if open_parens > closed_parens { - return &HINTENUM_CLOSED_PARENS; + return &HINT_CLOSED_PARENS; } let len = chars.len(); @@ -36,49 +36,44 @@ pub fn generate_hint<'a>(input: &str) -> &'a HintEnum<'a> { } } - &HintEnum::None + &Hint::None } #[derive(PartialEq)] -pub enum HintEnum<'a> { +pub enum Hint<'a> { Single(&'a str), Many(&'a [&'a str]), None, } -impl<'a> std::fmt::Debug for HintEnum<'a> { +impl<'a> std::fmt::Debug for Hint<'a> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self) } } -impl<'a> std::fmt::Display for HintEnum<'a> { +impl<'a> std::fmt::Display for Hint<'a> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - HintEnum::Single(single_data) => { + Hint::Single(single_data) => { return write!(f, "{}", single_data); } - HintEnum::Many(multi_data) => { + Hint::Many(multi_data) => { return write!(f, "{:?}", multi_data); } - HintEnum::None => { + Hint::None => { return write!(f, "None"); } } } } -impl<'a> HintEnum<'a> { - pub fn is_none(&self) -> bool { matches!(self, HintEnum::None) } +impl<'a> Hint<'a> { + pub fn is_none(&self) -> bool { matches!(self, Hint::None) } #[allow(dead_code)] pub fn is_some(&self) -> bool { !self.is_none() } #[allow(dead_code)] - pub fn is_single(&self) -> bool { - match self { - HintEnum::Single(_) => true, - _ => false, - } - } + pub fn is_single(&self) -> bool { matches!(self, Hint::Single(_)) } } include!(concat!(env!("OUT_DIR"), "/codegen.rs")); @@ -93,13 +88,13 @@ mod tests { #[test] fn hint_test() { let values = HashMap::from([ - ("", HintEnum::Single("x^2")), - ("si", HintEnum::Many(&["n(", "nh(", "gnum("])), - ("log", HintEnum::Many(&["2(", "10("])), - ("cos", HintEnum::Many(&["(", "h("])), - ("sin(", HintEnum::Single(")")), - ("sqrt", HintEnum::Single("(")), - ("ln(x)", HintEnum::None), + ("", Hint::Single("x^2")), + ("si", Hint::Many(&["n(", "nh(", "gnum("])), + ("log", Hint::Many(&["2(", "10("])), + ("cos", Hint::Many(&["(", "h("])), + ("sin(", Hint::Single(")")), + ("sqrt", Hint::Single("(")), + ("ln(x)", Hint::None), ]); for (key, value) in values { @@ -111,13 +106,13 @@ mod tests { #[test] fn hint_to_string_test() { let values = HashMap::from([ - ("x^2", HintEnum::Single("x^2")), + ("x^2", Hint::Single("x^2")), ( r#"["n(", "nh(", "gnum("]"#, - HintEnum::Many(&["n(", "nh(", "gnum("]), + Hint::Many(&["n(", "nh(", "gnum("]), ), - (r#"["n("]"#, HintEnum::Many(&["n("])), - ("None", HintEnum::None), + (r#"["n("]"#, Hint::Many(&["n("])), + ("None", Hint::None), ]); for (key, value) in values { diff --git a/src/widgets.rs b/src/widgets.rs index 54fda6b..32a46d5 100644 --- a/src/widgets.rs +++ b/src/widgets.rs @@ -1,4 +1,4 @@ -use crate::suggestions::{generate_hint, HintEnum}; +use crate::suggestions::{generate_hint, Hint}; use eframe::{egui, epaint}; use egui::{text::CCursor, text_edit::CursorRange, Key, Modifiers, TextEdit, Widget}; use epaint::text::cursor::{Cursor, PCursor, RCursor}; @@ -14,7 +14,7 @@ enum Movement { #[derive(Clone)] pub struct AutoComplete<'a> { pub i: usize, - pub hint: &'a HintEnum<'a>, + pub hint: &'a Hint<'a>, pub string: String, } @@ -26,14 +26,14 @@ impl<'a> Default for AutoComplete<'a> { fn default() -> AutoComplete<'a> { AutoComplete { i: 0, - hint: &crate::suggestions::HINTENUM_EMPTY, + hint: &crate::suggestions::HINT_EMPTY, string: String::new(), } } } impl<'a> AutoComplete<'a> { - pub fn update(&mut self, string: &str) { + pub fn update_string(&mut self, string: &str) { if &self.string != string { self.i = 0; self.string = string.to_string(); @@ -47,7 +47,7 @@ impl<'a> AutoComplete<'a> { } match self.hint { - HintEnum::Many(hints) => { + Hint::Many(hints) => { if movement == &Movement::Complete { self.apply_hint(hints[self.i]); return; @@ -71,18 +71,18 @@ impl<'a> AutoComplete<'a> { _ => unreachable!(), } } - HintEnum::Single(hint) => { + Hint::Single(hint) => { if movement == &Movement::Complete { self.apply_hint(hint); } } - HintEnum::None => {} + Hint::None => {} } } fn apply_hint(&mut self, hint: &str) { let new_string = self.string.clone() + hint; - self.update(&new_string); + self.update_string(&new_string); } pub fn ui(&mut self, ui: &mut egui::Ui, func_i: i32) { @@ -99,7 +99,7 @@ impl<'a> AutoComplete<'a> { if self.hint.is_none() { let _ = func_edit.ui(ui); - self.update(&new_string); + self.update_string(&new_string); return; } @@ -110,7 +110,7 @@ impl<'a> AutoComplete<'a> { movement = Movement::Complete; } - if let HintEnum::Single(single_hint) = self.hint { + if let Hint::Single(single_hint) = self.hint { func_edit = func_edit.hint_text(*single_hint); if ui.input().key_pressed(Key::ArrowDown) { movement = Movement::Down; @@ -121,11 +121,11 @@ impl<'a> AutoComplete<'a> { let re = func_edit.ui(ui); - self.update(&new_string); + self.update_string(&new_string); self.interact_back(&movement); - if movement != Movement::Complete && let HintEnum::Many(hints) = self.hint { + if movement != Movement::Complete && let Hint::Many(hints) = self.hint { // Doesn't need to have a number in id as there should only be 1 autocomplete popup in the entire gui let popup_id = ui.make_persistent_id("autocomplete_popup"); @@ -205,34 +205,34 @@ mod autocomplete_tests { } } Action::AssertHint(target_hint) => match ac.hint { - HintEnum::None => { + Hint::None => { if !target_hint.is_empty() { panic!( - "AssertHint failed on `HintEnum::None`: Expected: {}", + "AssertHint failed on `Hint::None`: Expected: {}", target_hint ); } } - HintEnum::Many(hints) => { + Hint::Many(hints) => { let hint = hints[ac.i]; if &hint != target_hint { panic!( - "AssertHint failed on `HintEnum::Many`: Current: '{}' (index: {}) Expected: '{}'", + "AssertHint failed on `Hint::Many`: Current: '{}' (index: {}) Expected: '{}'", hint, ac.i, target_hint ) } } - HintEnum::Single(hint) => { + Hint::Single(hint) => { if hint != target_hint { panic!( - "AssertHint failed on `HintEnum::Single`: Current: '{}' Expected: '{}'", + "AssertHint failed on `Hint::Single`: Current: '{}' Expected: '{}'", hint, target_hint ) } } }, Action::SetString(target_string) => { - ac.update(target_string); + ac.update_string(target_string); } Action::Move(target_movement) => { ac.interact_back(target_movement);