Add search thread and Searchable trait

This is the start of allowing for searches to be run in a separate
thread, using a reusable interface.

Author: MitMaro

Cargo.lock

@@ -18,6 +18,7 @@ name = "core"
 anyhow = "1.0.68"
 bitflags = "1.3.2"
 captur = "0.1.0"
+crossbeam-channel = "0.5.6"
 if_chain = "1.0.2"
 lazy_static = "1.4.0"
 num-format = "0.4.4"

src/core/Cargo.toml

@@ -127,6 +127,8 @@ mod license;
 mod module;
 mod modules;
 mod process;
+#[allow(dead_code)]
+mod search;
 #[cfg(test)]
 mod tests;
 #[cfg(test)]

src/core/src/lib.rs

@@ -0,0 +1,52 @@
+use std::fmt::{Debug, Formatter};
+
+use crate::search::searchable::Searchable;
+
+#[allow(clippy::exhaustive_enums)]
+pub(crate) enum Action {
+	Cancel,
+	Continue,
+	End,
+	SetSearchable(Box<dyn Searchable>),
+	Start(String),
+}
+
+impl Debug for Action {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		match *self {
+			Self::Cancel => write!(f, "Cancel"),
+			Self::Continue => write!(f, "Continue"),
+			Self::End => write!(f, "End"),
+			Self::SetSearchable(_) => write!(f, "SetSearchable(_)"),
+			Self::Start(ref term) => write!(f, "Start({term})"),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use rstest::rstest;
+
+	use super::*;
+	use crate::search::{Interrupter, SearchResult};
+
+	struct TestSearchable;
+
+	impl Searchable for TestSearchable {
+		fn reset(&mut self) {}
+
+		fn search(&mut self, _: Interrupter, _: &str) -> SearchResult {
+			SearchResult::None
+		}
+	}
+
+	#[rstest]
+	#[case::cancel(Action::Cancel, "Cancel")]
+	#[case::cont(Action::Continue, "Continue")]
+	#[case::end(Action::End, "End")]
+	#[case::set_searchable(Action::SetSearchable(Box::new(TestSearchable {})), "SetSearchable(_)")]
+	#[case::start(Action::Start(String::from("foo")), "Start(foo)")]
+	fn debug(#[case] action: Action, #[case] expected: &str) {
+		assert_eq!(format!("{action:?}"), expected);
+	}
+}

src/core/src/search/action.rs

@@ -0,0 +1,42 @@
+use std::{
+	ops::Add,
+	time::{Duration, Instant},
+};
+
+pub(crate) struct Interrupter {
+	finish: Instant,
+}
+
+impl Interrupter {
+	pub(crate) fn new(duration: Duration) -> Self {
+		Self {
+			finish: Instant::now().add(duration),
+		}
+	}
+
+	pub(crate) fn should_continue(&self) -> bool {
+		Instant::now() < self.finish
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use std::{ops::Sub, time::Duration};
+
+	use super::*;
+	use crate::search::Interrupter;
+
+	#[test]
+	fn should_continue_before_finish() {
+		let interrupter = Interrupter::new(Duration::from_secs(60));
+		assert!(interrupter.should_continue());
+	}
+
+	#[test]
+	fn should_continue_after_finish() {
+		let interrupter = Interrupter {
+			finish: Instant::now().sub(Duration::from_secs(60)),
+		};
+		assert!(!interrupter.should_continue());
+	}
+}

src/core/src/search/interrupter.rs

@@ -0,0 +1,18 @@
+mod action;
+mod interrupter;
+mod search_result;
+mod search_state;
+mod searchable;
+mod state;
+mod thread;
+
+#[allow(unused_imports)]
+pub(crate) use self::{
+	action::Action,
+	interrupter::Interrupter,
+	search_result::SearchResult,
+	search_state::SearchState,
+	searchable::Searchable,
+	state::State,
+	thread::Thread,
+};

src/core/src/search/mod.rs

@@ -0,0 +1,6 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SearchResult {
+	None,
+	Complete,
+	Updated,
+}

src/core/src/search/search_result.rs

@@ -0,0 +1,6 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SearchState {
+	Inactive,
+	Active,
+	Complete,
+}

src/core/src/search/search_state.rs

@@ -0,0 +1,7 @@
+use crate::search::{Interrupter, SearchResult};
+
+pub(crate) trait Searchable: Send {
+	fn reset(&mut self);
+
+	fn search(&mut self, interrupter: Interrupter, term: &str) -> SearchResult;
+}

src/core/src/search/searchable.rs

@@ -0,0 +1,116 @@
+use std::{
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+	time::Duration,
+};
+
+use crossbeam_channel::RecvTimeoutError;
+
+use crate::search::action::Action;
+
+const RECEIVE_TIMEOUT: Duration = Duration::from_millis(500);
+
+#[derive(Clone, Debug)]
+pub(crate) struct State {
+	ended: Arc<AtomicBool>,
+	paused: Arc<AtomicBool>,
+	update_receiver: crossbeam_channel::Receiver<Action>,
+	update_sender: crossbeam_channel::Sender<Action>,
+}
+
+impl State {
+	pub(crate) fn new() -> Self {
+		let (update_sender, update_receiver) = crossbeam_channel::unbounded();
+		Self {
+			ended: Arc::new(AtomicBool::from(false)),
+			paused: Arc::new(AtomicBool::from(false)),
+			update_receiver,
+			update_sender,
+		}
+	}
+
+	pub(crate) fn receive_update(&self) -> Action {
+		self.update_receiver
+			.recv_timeout(RECEIVE_TIMEOUT)
+			.unwrap_or_else(|e: RecvTimeoutError| {
+				match e {
+					RecvTimeoutError::Timeout => Action::Continue,
+					RecvTimeoutError::Disconnected => Action::End,
+				}
+			})
+	}
+
+	pub(crate) fn send_update(&self, action: Action) {
+		let _result = self.update_sender.send(action);
+	}
+
+	pub(crate) fn is_paused(&self) -> bool {
+		self.paused.load(Ordering::Acquire)
+	}
+
+	pub(crate) fn is_ended(&self) -> bool {
+		self.ended.load(Ordering::Acquire)
+	}
+
+	pub(crate) fn pause(&self) {
+		self.paused.store(true, Ordering::Release);
+	}
+
+	pub(crate) fn resume(&self) {
+		self.paused.store(false, Ordering::Release);
+	}
+
+	pub(crate) fn end(&self) {
+		self.ended.store(true, Ordering::Release);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+
+	use super::*;
+
+	#[test]
+	fn send_recv_update() {
+		let state = State::new();
+		state.send_update(Action::Start(String::from("test")));
+		assert!(matches!(state.receive_update(), Action::Start(_)));
+	}
+
+	#[test]
+	fn send_recv_update_timeout() {
+		let state = State::new();
+		assert!(matches!(state.receive_update(), Action::Continue));
+	}
+
+	#[test]
+	fn send_recv_disconnect() {
+		let (update_sender, _update_receiver) = crossbeam_channel::unbounded();
+		let mut state = State::new();
+		state.update_sender = update_sender; // replace last reference to sender, to force a disconnect
+		assert!(matches!(state.receive_update(), Action::End));
+	}
+
+	#[test]
+	fn paused() {
+		let state = State::new();
+		state.pause();
+		assert!(state.is_paused());
+	}
+
+	#[test]
+	fn resumed() {
+		let state = State::new();
+		state.resume();
+		assert!(!state.is_paused());
+	}
+
+	#[test]
+	fn ended() {
+		let state = State::new();
+		state.end();
+		assert!(state.is_ended());
+	}
+}