use egui::{Align2, Context, Key, Modifiers, TextEdit as EguiTextEdit, Window, vec2};
use crate::search::{find_matches, replace_all, replace_range};
#[derive(Default)]
pub(super) struct Search {
pub(super) open: bool,
pub(super) replacing: bool,
pub(super) term: String,
pub(super) replacement: String,
pub(super) last_term: Option<String>,
}
pub(super) struct SearchOutput {
pub(super) cursor: Option<(usize, usize)>,
pub(super) edited: bool,
}
impl Search {
pub(super) fn open(&mut self, initial: String, replacing: bool) {
if !initial.is_empty() {
self.term = initial;
}
self.replacing = replacing;
self.open = true;
}
pub(super) fn jump_to_match(
&self,
text: &str,
cursor: usize,
anchor: usize,
forward: bool,
) -> Option<(usize, usize)> {
let term = self.last_term.as_ref()?;
let matches = find_matches(text, term);
if matches.is_empty() {
return None;
}
let length = term.chars().count();
let next = if forward {
matches
.iter()
.find(|&&position| position > cursor)
.or_else(|| matches.first())
} else {
let start = anchor.min(cursor);
matches
.iter()
.rev()
.find(|&&position| position < start)
.or_else(|| matches.last())
}?;
Some((next + length, *next))
}
fn replace_current(&self, text: &mut String, cursor: usize, anchor: usize) -> (usize, usize) {
let start = cursor.min(anchor);
let length = self.term.chars().count();
let selected: String = text.chars().skip(start).take(length).collect();
if cursor == anchor || find_matches(&selected, &self.term).first() != Some(&0) {
return (cursor, anchor);
}
*text = replace_range(text, start, length, &self.replacement);
let end = start + self.replacement.chars().count();
(end, end)
}
pub(super) fn draw(
&mut self,
ctx: &Context,
text: &mut String,
cursor: usize,
anchor: usize,
id_source: impl std::hash::Hash + std::fmt::Debug,
) -> SearchOutput {
let mut output = SearchOutput {
cursor: None,
edited: false,
};
if !self.open {
return output;
}
if ctx.input_mut(|input| input.consume_key(Modifiers::NONE, Key::Escape)) {
self.open = false;
return output;
}
let forward = ctx.input_mut(|input| input.consume_key(Modifiers::NONE, Key::Tab));
let backward = ctx.input_mut(|input| input.consume_key(Modifiers::SHIFT, Key::Tab));
let entered = ctx.input_mut(|input| input.consume_key(Modifiers::NONE, Key::Enter));
let mut replace_every =
ctx.input_mut(|input| input.consume_key(Modifiers::CTRL, Key::Enter));
let mut replace_one = entered && self.replacing;
let confirm = entered && !self.replacing;
let title = if self.replacing { "Replace" } else { "Find" };
Window::new(title)
.id(egui::Id::new("idet-core-search").with(id_source))
.collapsible(false)
.resizable(false)
.anchor(Align2::CENTER_TOP, vec2(0.0, 40.0))
.show(ctx, |ui| {
let response =
ui.add(EguiTextEdit::singleline(&mut self.term).desired_width(240.0));
if response.changed() {
self.last_term = Some(self.term.clone());
}
if self.replacing {
ui.add(EguiTextEdit::singleline(&mut self.replacement).desired_width(240.0));
}
if !response.has_focus() && !response.lost_focus() && !self.replacing {
response.request_focus();
}
let matches = find_matches(text, &self.term);
if !self.term.is_empty() {
ui.label(format!("{} match(es)", matches.len()));
}
if self.replacing {
ui.horizontal(|ui| {
replace_one |= ui.button("Replace (Enter)").clicked();
replace_every |= ui.button("Replace all (Ctrl+Enter)").clicked();
});
}
});
if forward || backward {
self.last_term = Some(self.term.clone());
output.cursor = self.jump_to_match(text, cursor, anchor, forward);
}
if replace_one && !self.term.is_empty() {
self.last_term = Some(self.term.clone());
let (moved_cursor, moved_anchor) = self.replace_current(text, cursor, anchor);
output.edited = moved_cursor != cursor || moved_anchor != anchor;
output.cursor = self
.jump_to_match(text, moved_cursor, moved_anchor, true)
.or(Some((moved_cursor, moved_anchor)));
}
if replace_every && !self.term.is_empty() {
let (replaced, count) = replace_all(text, &self.term, &self.replacement);
if count > 0 {
*text = replaced;
output.edited = true;
let position = cursor.min(text.chars().count());
output.cursor = Some((position, position));
}
self.open = false;
}
if confirm {
self.last_term = Some(self.term.clone());
output.cursor = self.jump_to_match(text, cursor, anchor, true);
self.open = false;
}
output
}
}
#[cfg(test)]
mod tests {
use super::Search;
fn replacing(term: &str, replacement: &str) -> Search {
Search {
open: true,
replacing: true,
term: term.to_owned(),
replacement: replacement.to_owned(),
last_term: None,
}
}
#[test]
fn a_selected_match_is_replaced_and_the_cursor_follows_it() {
let mut text = "alpha beta".to_owned();
let search = replacing("alpha", "omega");
assert_eq!(search.replace_current(&mut text, 5, 0), (5, 5));
assert_eq!(text, "omega beta");
}
#[test]
fn a_selection_that_is_not_the_term_is_left_alone() {
let mut text = "alpha beta".to_owned();
let search = replacing("alpha", "omega");
assert_eq!(search.replace_current(&mut text, 10, 6), (10, 6));
assert_eq!(text, "alpha beta");
}
#[test]
fn nothing_selected_replaces_nothing() {
let mut text = "alpha beta".to_owned();
let search = replacing("alpha", "omega");
assert_eq!(search.replace_current(&mut text, 3, 3), (3, 3));
assert_eq!(text, "alpha beta");
}
#[test]
fn a_shorter_replacement_leaves_the_cursor_at_its_end() {
let mut text = "alpha beta".to_owned();
let search = replacing("alpha", "hi");
assert_eq!(search.replace_current(&mut text, 5, 0), (2, 2));
assert_eq!(text, "hi beta");
}
}