Move clipboard to core

Author: thorio

Cargo.lock

@@ -7,6 +7,7 @@ edition.workspace = true
 gravel-ffi = { path = "../gravel-ffi" }
 
 abi_stable.workspace = true
+arboard.workspace = true
 enumflags2.workspace = true
 fuzzy-matcher.workspace = true
 hotkey.workspace = true

gravel-core/Cargo.toml

@@ -0,0 +1,41 @@
+use std::sync::Mutex;
+
+pub struct Clipboard {
+	inner: Option<Mutex<arboard::Clipboard>>,
+}
+
+impl Clipboard {
+	#[expect(clippy::new_without_default)]
+	pub fn new() -> Self {
+		Self {
+			inner: create_clipboard().map(Mutex::new),
+		}
+	}
+
+	pub fn set_text(&self, content: &str) {
+		log::trace!("setting clipboard to {content}");
+
+		let Some(mutex) = &self.inner else {
+			log::trace!("clipboard not initialized, canceling operation");
+			return;
+		};
+
+		let Ok(mut clipboard) = mutex.lock() else {
+			log::error!("clipboard mutex poisened, canceling operation");
+			return;
+		};
+
+		clipboard
+			.set_text(content)
+			.inspect_err(|e| log::error!("unable to set clipboard: {e}"))
+			.ok();
+	}
+}
+
+fn create_clipboard() -> Option<arboard::Clipboard> {
+	log::trace!("spawning clipboard instance");
+
+	arboard::Clipboard::new()
+		.inspect_err(|e| log::error!("unable to initialize clipboard: {e}"))
+		.ok()
+}

gravel-core/src/clipboard.rs

@@ -178,6 +178,10 @@ impl HitActionContext for ActionContext {
 		self.send_frontend(FrontendMessage::ShowWithQuery(query));
 	}
 
+	fn set_clipboard_text(&self, content: RString) {
+		self.send(CoreMessage::SetClipboardText(content.into_rust()));
+	}
+
 	fn clear_caches(&self) {
 		self.send(CoreMessage::ClearCaches);
 	}

gravel-core/src/engine.rs

@@ -13,6 +13,9 @@ use gravel_ffi::{BoxDynFrontendContext, FrontendContext, FrontendMessage, Fronte
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::{thread, time::Duration};
 
+use crate::clipboard::Clipboard;
+
+pub mod clipboard;
 pub mod config;
 pub mod engine;
 pub mod hotkeys;
@@ -25,13 +28,15 @@ pub struct Core {
 	engine: QueryEngine,
 	frontend_sender: RSender<FrontendMessageNe>,
 	receiver: RReceiver<CoreMessage>,
+	clipboard: Clipboard,
 }
 
 pub enum CoreMessage {
 	Frontend(FrontendMessage),
 	Query(u32, String),
 	RunAction(ArcDynHit, ActionKind),
 	ClearCaches,
+	SetClipboardText(String),
 }
 
 impl Core {
@@ -44,6 +49,7 @@ impl Core {
 			engine,
 			frontend_sender,
 			receiver,
+			clipboard: Clipboard::new(),
 		}
 	}
 
@@ -65,6 +71,7 @@ impl Core {
 			CoreMessage::Query(token, query) => self.query(token, &query),
 			CoreMessage::RunAction(hit, kind) => self.run_action(&hit, kind),
 			CoreMessage::ClearCaches => self.clear_caches(),
+			CoreMessage::SetClipboardText(content) => self.clipboard.set_text(&content),
 		}
 
 		None

gravel-core/src/lib.rs

@@ -104,6 +104,9 @@ pub trait HitActionContext {
 
 	/// Clears caches in the entire application.
 	fn clear_caches(&self);
+
+	/// Writes to the system clipboard.
+	fn set_clipboard_text(&self, content: RString);
 }
 
 type SimpleHitAction = Box<dyn Fn(&SimpleHit, RefDynHitActionContext<'_>) + Send + Sync>;

gravel-ffi/src/hit.rs

@@ -36,7 +36,6 @@ pub trait ProviderInner: Send {
 ///     }
 ///
 ///     fn query(&self, query: &str) -> ProviderResult {
-///
 ///         ProviderResult::empty()
 ///     }
 /// }
@@ -76,6 +75,12 @@ impl ProviderResult {
 		Self { hits }
 	}
 
+	/// Constructs a new [`ProviderResult`] with one or no hits.
+	#[must_use]
+	pub fn from_option(hit: Option<impl Into<ArcDynHit>>) -> Self {
+		hit.map_or_else(Self::empty, Self::single)
+	}
+
 	/// Constructs an empty [`ProviderResult`].
 	#[must_use]
 	pub fn empty() -> Self {

gravel-ffi/src/provider.rs

@@ -13,8 +13,6 @@ no-root = []
 gravel-ffi = { path = "../gravel-ffi" }
 
 abi_stable.workspace = true
-arboard.workspace = true
-log.workspace = true
 mexprp.workspace = true
 serde.workspace = true
 

gravel-provider-calculator/Cargo.toml

@@ -5,68 +5,51 @@
 //!
 //! Selecting the hit copies the calculated value to the system's clipboard.
 
-use arboard::Clipboard;
+use abi_stable::reexports::SelfOps;
 use gravel_ffi::prelude::*;
 use mexprp::Answer;
 use serde::Deserialize;
-use std::cell::OnceCell;
-use std::sync::{Arc, Mutex};
 
 const DEFAULT_CONFIG: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/config.yml"));
 
 struct CalculatorProvider {
 	config: Config,
-	clipboard: OnceCell<Option<Arc<Mutex<Clipboard>>>>,
-}
-
-impl CalculatorProvider {
-	fn get_clipboard(&self) -> Option<Arc<Mutex<Clipboard>>> {
-		self.clipboard.get_or_init(create_clipboard).clone()
-	}
 }
 
 #[gravel_provider("calculator")]
 impl Provider for CalculatorProvider {
 	fn new(config: &PluginConfigAdapter<'_>) -> Self {
 		Self {
 			config: config.get(DEFAULT_CONFIG),
-			clipboard: OnceCell::new(),
 		}
 	}
 
 	fn query(&self, query: &str) -> ProviderResult {
 		let query = query.trim();
-		let result = eval(query);
-
-		let Some(result) = result else {
-			return ProviderResult::empty();
-		};
 
-		if query == result || matches!(query, "e" | "pi" | "i") {
-			return ProviderResult::empty();
-		}
-
-		let clipboard = self.get_clipboard();
+		eval(query)
+			.filter(|r| !query_was_const(query, r))
+			.map(|r| self.get_hit(r))
+			.piped(ProviderResult::from_option)
+	}
+}
 
-		let hit = SimpleHit::new(result, self.config.subtitle.clone(), move |hit, ctx| {
-			do_copy(clipboard.clone(), hit.title().as_str(), ctx);
+impl CalculatorProvider {
+	fn get_hit(&self, result: String) -> SimpleHit {
+		SimpleHit::new(result, self.config.subtitle.clone(), move |hit, ctx| {
+			ctx.set_clipboard_text(hit.title().to_string().into_c());
+			ctx.hide_frontend();
 		})
 		.with_secondary(|hit, ctx| {
-			ctx.set_query(hit.title().into_rust().to_owned().into_c());
+			ctx.set_query(hit.title().as_str().to_owned().into_c());
 		})
-		.with_score(MAX_SCORE);
-
-		ProviderResult::single(hit)
+		.with_score(MAX_SCORE)
 	}
 }
 
-fn create_clipboard() -> Option<Arc<Mutex<Clipboard>>> {
-	log::trace!("spawning clipboard instance");
-
-	Clipboard::new()
-		.inspect_err(|e| log::error!("unable to initialize clipboard: {e}"))
-		.ok()
-		.map(|c| Arc::new(Mutex::new(c)))
+// queries that do not require any calculation should be ignored
+fn query_was_const(query: &str, result: &str) -> bool {
+	query == result || matches!(query, "e" | "pi" | "i")
 }
 
 fn eval(expression: &str) -> Option<String> {
@@ -78,22 +61,6 @@ fn eval(expression: &str) -> Option<String> {
 	.map(|r| round(r, 10).to_string())
 }
 
-fn do_copy(clipboard: Option<Arc<Mutex<Clipboard>>>, result: &str, context: RefDynHitActionContext<'_>) {
-	let Some(clipboard_mutex) = clipboard else {
-		return;
-	};
-
-	log::debug!("copying value to clipboard: {result}");
-
-	let mut guard = clipboard_mutex.lock().expect("thread holding the mutex can't panic");
-	guard
-		.set_text(result)
-		.inspect_err(|e| log::error!("unable to set clipboard: {e}"))
-		.ok();
-
-	context.hide_frontend();
-}
-
 fn round(number: f64, precision: u32) -> f64 {
 	let factor = 10_u64.pow(precision) as f64;
 	(number * factor).round() / factor

gravel-provider-calculator/src/lib.rs

@@ -10,6 +10,7 @@ mock! {
 		fn exit(&self);
 		fn restart(&self);
 		fn set_query(&self, query: RString);
+		fn set_clipboard_text(&self, content: RString);
 		fn clear_caches(&self);
 	}
 }