titaniumtown/YTBN-Graphing-Software
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename HintEnum and some cleanup

Browse Source
This commit is contained in:
Simon Gardling 2022-04-12 10:17:04 -04:00
parent d2298e69a2
commit 2b684ecb88
5 changed files with 58 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build.rs
View File

@ -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");

22
src/autocomplete_helper.rs
View File

@ -34,7 +34,7 @@ pub fn compile_hashmap(data: Vec<String>) -> 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<String>) -> Vec<(String, String)> {
.map(|(_, b)| b)
.collect::<Vec<&String>>();
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!(

2
src/function.rs
View File

@ -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();

57
src/suggestions.rs
View File

@ -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<String>`
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<char> = input.chars().collect::<Vec<char>>();
@ -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 {

38
src/widgets.rs
View File

@ -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);