Integrate search thread and handling

Author: MitMaro

src/core/src/application.rs

@@ -4,18 +4,20 @@ use anyhow::Result;
 use config::Config;
 use display::Display;
 use git::Repository;
-use input::{EventHandler, EventReaderFn};
+use input::{Event, EventHandler, EventReaderFn};
 use parking_lot::Mutex;
 use runtime::{Runtime, Threadable};
 use todo_file::TodoFile;
 use view::View;
 
 use crate::{
 	events,
-	events::KeyBindings,
+	events::{KeyBindings, MetaEvent},
 	help::build_help,
 	module::{self, ExitStatus, ModuleHandler},
 	process::{self, Process},
+	search,
+	search::UpdateHandlerFn,
 	Args,
 	Exit,
 };
@@ -71,12 +73,18 @@ where ModuleProvider: module::ModuleProvider + Send + 'static
 		let view_state = view_threads.state();
 		threads.push(Box::new(view_threads));
 
+		let search_update_handler = Self::create_search_update_handler(input_state.clone());
+		let search_threads = search::Thread::new(search_update_handler);
+		let search_state = search_threads.state();
+		threads.push(Box::new(search_threads));
+
 		let process = Process::new(
 			initial_display_size,
 			todo_file,
 			module_handler,
 			input_state,
 			view_state,
+			search_state,
 			runtime.statuses(),
 		);
 		let process_threads = process::Thread::new(process.clone());
@@ -160,6 +168,10 @@ where ModuleProvider: module::ModuleProvider + Send + 'static
 
 		Ok(todo_file)
 	}
+
+	fn create_search_update_handler(input_state: events::State) -> impl Fn() + Send + Sync {
+		move || input_state.push_event(Event::MetaEvent(MetaEvent::SearchUpdate))
+	}
 }
 
 #[cfg(all(unix, test))]
@@ -290,6 +302,19 @@ mod tests {
 		);
 	}
 
+	#[test]
+	#[serial_test::serial]
+	fn search_update_handler_handles_update() {
+		let event_provider = create_event_reader(|| Ok(None));
+		let input_threads = events::Thread::new(event_provider);
+		let input_state = input_threads.state();
+		let update_handler =
+			Application::<TestModuleProvider<DefaultTestModule>>::create_search_update_handler(input_state.clone());
+		update_handler();
+
+		assert_eq!(input_state.read_event(), Event::MetaEvent(MetaEvent::SearchUpdate));
+	}
+
 	#[test]
 	#[serial_test::serial]
 	fn run_until_finished_success() {

src/core/src/events/meta_event.rs

@@ -70,6 +70,8 @@ pub(crate) enum MetaEvent {
 	ExternalCommandSuccess,
 	/// The external command was an error meta event.
 	ExternalCommandError,
+	/// Search was updated
+	SearchUpdate,
 }
 
 impl input::CustomEvent for MetaEvent {}

src/core/src/lib.rs

@@ -113,7 +113,8 @@
 	clippy::redundant_closure_for_method_calls,
 	clippy::wildcard_enum_match_arm,
 	missing_docs,
-	rustdoc::missing_crate_level_docs
+	rustdoc::missing_crate_level_docs,
+	unused
 )]
 
 mod application;
@@ -127,7 +128,6 @@ mod license;
 mod module;
 mod modules;
 mod process;
-#[allow(dead_code)]
 mod search;
 #[cfg(test)]
 mod tests;

src/core/src/process/artifact.rs

@@ -1,17 +1,67 @@
+use std::fmt::{Debug, Formatter};
+
 use anyhow::Error;
 
 use crate::{
 	events::Event,
 	module::{ExitStatus, State},
+	search::Searchable,
 };
 
-#[derive(Debug)]
 #[allow(variant_size_differences)]
 pub(crate) enum Artifact {
-	Event(Event),
 	ChangeState(State),
+	EnqueueResize,
 	Error(Error, Option<State>),
+	Event(Event),
 	ExitStatus(ExitStatus),
 	ExternalCommand((String, Vec<String>)),
-	EnqueueResize,
+	SearchCancel,
+	SearchTerm(String),
+	Searchable(Box<dyn Searchable>),
+}
+
+impl Debug for Artifact {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		match *self {
+			Self::ChangeState(state) => write!(f, "ChangeState({state:?})"),
+			Self::EnqueueResize => write!(f, "EnqueueResize"),
+			Self::Error(ref err, state) => write!(f, "Error({err:?}, {state:?})"),
+			Self::Event(event) => write!(f, "Event({event:?})"),
+			Self::ExitStatus(status) => write!(f, "ExitStatus({status:?})"),
+			Self::ExternalCommand((ref command, ref args)) => write!(f, "ExternalCommand({command:?}, {args:?})"),
+			Self::SearchCancel => write!(f, "SearchCancel"),
+			Self::SearchTerm(ref term) => write!(f, "SearchTerm({term:?})"),
+			Self::Searchable(_) => write!(f, "Searchable(dyn Searchable)"),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use anyhow::anyhow;
+	use rstest::rstest;
+
+	use super::*;
+	use crate::{
+		search::{Interrupter, SearchResult},
+		testutil::MockedSearchable,
+	};
+
+	#[rstest]
+	#[case::change_state(Artifact::ChangeState(State::List), "ChangeState(List)")]
+	#[case::enqueue_resize(Artifact::EnqueueResize, "EnqueueResize")]
+	#[case::error(Artifact::Error(anyhow!("Error"), Some(State::List)), "Error(Error, Some(List))")]
+	#[case::event(Artifact::Event(Event::None), "Event(None)")]
+	#[case::exit_status(Artifact::ExitStatus(ExitStatus::Abort), "ExitStatus(Abort)")]
+	#[case::external_command(Artifact::ExternalCommand((String::from("foo"), vec![])), "ExternalCommand(\"foo\", [])")]
+	#[case::search_cancel(Artifact::SearchCancel, "SearchCancel")]
+	#[case::search_term(Artifact::SearchTerm(String::from("foo")), "SearchTerm(\"foo\")")]
+	#[case::searchable(
+		Artifact::Searchable(Box::new(MockedSearchable::new())),
+		"Searchable(dyn Searchable)"
+	)]
+	fn debug(#[case] artifact: Artifact, #[case] expected: &str) {
+		assert_eq!(format!("{artifact:?}"), expected);
+	}
 }

src/core/src/process/mod.rs

@@ -26,6 +26,7 @@ use crate::{
 	events,
 	events::{Event, MetaEvent},
 	module::{self, ExitStatus, ModuleHandler, State},
+	search::{self, Action, Searchable},
 };
 
 pub(crate) struct Process<ModuleProvider: module::ModuleProvider> {
@@ -39,6 +40,7 @@ pub(crate) struct Process<ModuleProvider: module::ModuleProvider> {
 	thread_statuses: ThreadStatuses,
 	todo_file: Arc<Mutex<TodoFile>>,
 	view_state: view::State,
+	search_state: search::State,
 }
 
 impl<ModuleProvider: module::ModuleProvider> Clone for Process<ModuleProvider> {
@@ -54,6 +56,7 @@ impl<ModuleProvider: module::ModuleProvider> Clone for Process<ModuleProvider> {
 			thread_statuses: self.thread_statuses.clone(),
 			todo_file: Arc::clone(&self.todo_file),
 			view_state: self.view_state.clone(),
+			search_state: self.search_state.clone(),
 		}
 	}
 }
@@ -65,6 +68,7 @@ impl<ModuleProvider: module::ModuleProvider> Process<ModuleProvider> {
 		module_handler: ModuleHandler<ModuleProvider>,
 		input_state: events::State,
 		view_state: view::State,
+		search_state: search::State,
 		thread_statuses: ThreadStatuses,
 	) -> Self {
 		Self {
@@ -77,6 +81,7 @@ impl<ModuleProvider: module::ModuleProvider> Process<ModuleProvider> {
 				initial_display_size.width(),
 				initial_display_size.height(),
 			))),
+			search_state,
 			state: Arc::new(Mutex::new(State::WindowSizeError)),
 			thread_statuses,
 			todo_file,
@@ -266,6 +271,21 @@ impl<ModuleProvider: module::ModuleProvider> Process<ModuleProvider> {
 		result
 	}
 
+	fn handle_search_cancel(&self) -> Results {
+		self.search_state.send_update(Action::Cancel);
+		Results::new()
+	}
+
+	fn handle_search_term(&self, term: String) -> Results {
+		self.search_state.send_update(Action::Start(term));
+		Results::new()
+	}
+
+	fn handle_searchable(&self, searchable: Box<dyn Searchable>) -> Results {
+		self.search_state.send_update(Action::SetSearchable(searchable));
+		Results::new()
+	}
+
 	fn handle_results(&self, mut results: Results) {
 		while let Some(artifact) = results.artifact() {
 			results.append(match artifact {
@@ -275,6 +295,9 @@ impl<ModuleProvider: module::ModuleProvider> Process<ModuleProvider> {
 				Artifact::Event(event) => self.handle_event_artifact(event),
 				Artifact::ExitStatus(exit_status) => self.handle_exit_status(exit_status),
 				Artifact::ExternalCommand(command) => self.handle_external_command(&command),
+				Artifact::SearchCancel => self.handle_search_cancel(),
+				Artifact::SearchTerm(search_term) => self.handle_search_term(search_term),
+				Artifact::Searchable(searchable) => self.handle_searchable(searchable),
 			});
 		}
 	}

src/core/src/process/results.rs

@@ -6,6 +6,7 @@ use crate::{
 	events::Event,
 	module::{ExitStatus, State},
 	process::artifact::Artifact,
+	search::Searchable,
 };
 
 #[derive(Debug)]
@@ -40,6 +41,14 @@ impl Results {
 		self.artifacts.push_back(Artifact::ChangeState(new_state));
 	}
 
+	pub(crate) fn search_cancel(&mut self) {
+		self.artifacts.push_back(Artifact::SearchCancel);
+	}
+
+	pub(crate) fn search_term(&mut self, term: &str) {
+		self.artifacts.push_back(Artifact::SearchTerm(String::from(term)));
+	}
+
 	pub(crate) fn external_command(&mut self, command: String, arguments: Vec<String>) {
 		self.artifacts
 			.push_back(Artifact::ExternalCommand((command, arguments)));
@@ -90,11 +99,20 @@ impl From<State> for Results {
 	}
 }
 
+impl From<Box<dyn Searchable>> for Results {
+	fn from(searchable: Box<dyn Searchable>) -> Self {
+		Self {
+			artifacts: VecDeque::from(vec![Artifact::Searchable(searchable)]),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use anyhow::anyhow;
 
 	use super::*;
+	use crate::testutil::MockedSearchable;
 
 	#[test]
 	fn empty() {
@@ -146,6 +164,28 @@ mod tests {
 		assert!(matches!(results.artifact(), Some(Artifact::ChangeState(State::List))));
 	}
 
+	#[test]
+	fn search_cancel() {
+		let mut results = Results::new();
+		results.search_cancel();
+		assert!(matches!(results.artifact(), Some(Artifact::SearchCancel)));
+	}
+
+	#[test]
+	fn search_term() {
+		let mut results = Results::new();
+		let search_term = String::from("foo");
+		results.search_term(search_term.as_str());
+		assert!(matches!(results.artifact(), Some(Artifact::SearchTerm(search_term))));
+	}
+
+	#[test]
+	fn searchable() {
+		let mocked_searchable: Box<dyn Searchable> = Box::new(MockedSearchable::new());
+		let mut results = Results::from(mocked_searchable);
+		assert!(matches!(results.artifact(), Some(Artifact::Searchable(_))));
+	}
+
 	#[test]
 	fn external_command() {
 		let mut results = Results::new();

src/core/src/process/tests.rs

@@ -11,7 +11,14 @@ use crate::{
 	assert_results,
 	events::KeyBindings,
 	module::{Module, DEFAULT_INPUT_OPTIONS, DEFAULT_VIEW_DATA},
-	testutil::{create_default_test_module_handler, create_test_module_handler, process_test, ProcessTestContext},
+	search::{Interrupter, SearchResult},
+	testutil::{
+		create_default_test_module_handler,
+		create_test_module_handler,
+		process_test,
+		MockedSearchable,
+		ProcessTestContext,
+	},
 };
 
 #[derive(Clone)]
@@ -583,3 +590,64 @@ fn handle_results_external_command_success() {
 		},
 	);
 }
+
+#[test]
+fn handle_search_cancel() {
+	let module = TestModule::new();
+	process_test(
+		create_test_module_handler(module),
+		|ProcessTestContext {
+		     process,
+		     search_context,
+		     ..
+		 }| {
+			let mut results = Results::new();
+			results.search_cancel();
+			process.handle_results(results);
+			assert!(matches!(search_context.state.receive_update(), Action::Cancel));
+		},
+	);
+}
+
+#[test]
+fn handle_search_term() {
+	let module = TestModule::new();
+	process_test(
+		create_test_module_handler(module),
+		|ProcessTestContext {
+		     process,
+		     search_context,
+		     ..
+		 }| {
+			let mut results = Results::new();
+			let search_term = String::from("foo");
+			results.search_term(search_term.as_str());
+			process.handle_results(results);
+			assert!(matches!(
+				search_context.state.receive_update(),
+				Action::Start(search_term)
+			));
+		},
+	);
+}
+
+#[test]
+fn handle_searchable() {
+	let module = TestModule::new();
+	process_test(
+		create_test_module_handler(module),
+		|ProcessTestContext {
+		     process,
+		     search_context,
+		     ..
+		 }| {
+			let searchable: Box<dyn Searchable> = Box::new(MockedSearchable {});
+			let results = Results::from(searchable);
+			process.handle_results(results);
+			assert!(matches!(
+				search_context.state.receive_update(),
+				Action::SetSearchable(_)
+			));
+		},
+	);
+}