aboutsummaryrefslogtreecommitdiff
path: root/helix-event
diff options
context:
space:
mode:
Diffstat (limited to 'helix-event')
-rw-r--r--helix-event/Cargo.toml17
-rw-r--r--helix-event/src/cancel.rs19
-rw-r--r--helix-event/src/debounce.rs67
-rw-r--r--helix-event/src/hook.rs91
-rw-r--r--helix-event/src/lib.rs201
-rw-r--r--helix-event/src/redraw.rs24
-rw-r--r--helix-event/src/registry.rs131
-rw-r--r--helix-event/src/runtime.rs88
-rw-r--r--helix-event/src/status.rs68
-rw-r--r--helix-event/src/test.rs90
10 files changed, 781 insertions, 15 deletions
diff --git a/helix-event/Cargo.toml b/helix-event/Cargo.toml
index c2032824..a5c88e93 100644
--- a/helix-event/Cargo.toml
+++ b/helix-event/Cargo.toml
@@ -12,5 +12,18 @@ homepage.workspace = true
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot"] }
-parking_lot = { version = "0.12", features = ["send_guard"] }
+ahash = "0.8.3"
+hashbrown = "0.14.0"
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot", "macros"] }
+# the event registry is essentially read only but must be an rwlock so we can
+# setup new events on initialization, hardware-lock-elision hugely benefits this case
+# as it essentially makes the lock entirely free as long as there is no writes
+parking_lot = { version = "0.12", features = ["hardware-lock-elision"] }
+once_cell = "1.18"
+
+anyhow = "1"
+log = "0.4"
+futures-executor = "0.3.28"
+
+[features]
+integration_test = []
diff --git a/helix-event/src/cancel.rs b/helix-event/src/cancel.rs
new file mode 100644
index 00000000..f027be80
--- /dev/null
+++ b/helix-event/src/cancel.rs
@@ -0,0 +1,19 @@
+use std::future::Future;
+
+pub use oneshot::channel as cancelation;
+use tokio::sync::oneshot;
+
+pub type CancelTx = oneshot::Sender<()>;
+pub type CancelRx = oneshot::Receiver<()>;
+
+pub async fn cancelable_future<T>(future: impl Future<Output = T>, cancel: CancelRx) -> Option<T> {
+ tokio::select! {
+ biased;
+ _ = cancel => {
+ None
+ }
+ res = future => {
+ Some(res)
+ }
+ }
+}
diff --git a/helix-event/src/debounce.rs b/helix-event/src/debounce.rs
new file mode 100644
index 00000000..30b6f671
--- /dev/null
+++ b/helix-event/src/debounce.rs
@@ -0,0 +1,67 @@
+//! Utilities for declaring an async (usually debounced) hook
+
+use std::time::Duration;
+
+use futures_executor::block_on;
+use tokio::sync::mpsc::{self, error::TrySendError, Sender};
+use tokio::time::Instant;
+
+/// Async hooks provide a convenient framework for implementing (debounced)
+/// async event handlers. Most synchronous event hooks will likely need to
+/// debounce their events, coordinate multiple different hooks and potentially
+/// track some state. `AsyncHooks` facilitate these use cases by running as
+/// a background tokio task that waits for events (usually an enum) to be
+/// sent through a channel.
+pub trait AsyncHook: Sync + Send + 'static + Sized {
+ type Event: Sync + Send + 'static;
+ /// Called immediately whenever an event is received, this function can
+ /// consume the event immediately or debounce it. In case of debouncing,
+ /// it can either define a new debounce timeout or continue the current one
+ fn handle_event(&mut self, event: Self::Event, timeout: Option<Instant>) -> Option<Instant>;
+
+ /// Called whenever the debounce timeline is reached
+ fn finish_debounce(&mut self);
+
+ fn spawn(self) -> mpsc::Sender<Self::Event> {
+ // the capacity doesn't matter too much here, unless the cpu is totally overwhelmed
+ // the cap will never be reached since we always immediately drain the channel
+ // so it should only be reached in case of total CPU overload.
+ // However, a bounded channel is much more efficient so it's nice to use here
+ let (tx, rx) = mpsc::channel(128);
+ tokio::spawn(run(self, rx));
+ tx
+ }
+}
+
+async fn run<Hook: AsyncHook>(mut hook: Hook, mut rx: mpsc::Receiver<Hook::Event>) {
+ let mut deadline = None;
+ loop {
+ let event = match deadline {
+ Some(deadline_) => {
+ let res = tokio::time::timeout_at(deadline_, rx.recv()).await;
+ match res {
+ Ok(event) => event,
+ Err(_) => {
+ hook.finish_debounce();
+ deadline = None;
+ continue;
+ }
+ }
+ }
+ None => rx.recv().await,
+ };
+ let Some(event) = event else {
+ break;
+ };
+ deadline = hook.handle_event(event, deadline);
+ }
+}
+
+pub fn send_blocking<T>(tx: &Sender<T>, data: T) {
+ // block_on has some overhead and in practice the channel should basically
+ // never be full anyway so first try sending without blocking
+ if let Err(TrySendError::Full(data)) = tx.try_send(data) {
+ // set a timeout so that we just drop a message instead of freezing the editor in the worst case
+ let _ = block_on(tx.send_timeout(data, Duration::from_millis(10)));
+ }
+}
diff --git a/helix-event/src/hook.rs b/helix-event/src/hook.rs
new file mode 100644
index 00000000..7fb68148
--- /dev/null
+++ b/helix-event/src/hook.rs
@@ -0,0 +1,91 @@
+//! rust dynamic dispatch is extremely limited so we have to build our
+//! own vtable implementation. Otherwise implementing the event system would not be possible.
+//! A nice bonus of this approach is that we can optimize the vtable a bit more. Normally
+//! a dyn Trait fat pointer contains two pointers: A pointer to the data itself and a
+//! pointer to a global (static) vtable entry which itself contains multiple other pointers
+//! (the various functions of the trait, drop, size and align). That makes dynamic
+//! dispatch pretty slow (double pointer indirections). However, we only have a single function
+//! in the hook trait and don't need a drop implementation (event system is global anyway
+//! and never dropped) so we can just store the entire vtable inline.
+
+use anyhow::Result;
+use std::ptr::{self, NonNull};
+
+use crate::Event;
+
+/// Opaque handle type that represents an erased type parameter.
+///
+/// If extern types were stable, this could be implemented as `extern { pub type Opaque; }` but
+/// until then we can use this.
+///
+/// Care should be taken that we don't use a concrete instance of this. It should only be used
+/// through a reference, so we can maintain something else's lifetime.
+struct Opaque(());
+
+pub(crate) struct ErasedHook {
+ data: NonNull<Opaque>,
+ call: unsafe fn(NonNull<Opaque>, NonNull<Opaque>, NonNull<Opaque>),
+}
+
+impl ErasedHook {
+ pub(crate) fn new_dynamic<H: Fn() -> Result<()> + 'static + Send + Sync>(
+ hook: H,
+ ) -> ErasedHook {
+ unsafe fn call<F: Fn() -> Result<()> + 'static + Send + Sync>(
+ hook: NonNull<Opaque>,
+ _event: NonNull<Opaque>,
+ result: NonNull<Opaque>,
+ ) {
+ let hook: NonNull<F> = hook.cast();
+ let result: NonNull<Result<()>> = result.cast();
+ let hook: &F = hook.as_ref();
+ let res = hook();
+ ptr::write(result.as_ptr(), res)
+ }
+
+ unsafe {
+ ErasedHook {
+ data: NonNull::new_unchecked(Box::into_raw(Box::new(hook)) as *mut Opaque),
+ call: call::<H>,
+ }
+ }
+ }
+
+ pub(crate) fn new<E: Event, F: Fn(&mut E) -> Result<()>>(hook: F) -> ErasedHook {
+ unsafe fn call<E: Event, F: Fn(&mut E) -> Result<()>>(
+ hook: NonNull<Opaque>,
+ event: NonNull<Opaque>,
+ result: NonNull<Opaque>,
+ ) {
+ let hook: NonNull<F> = hook.cast();
+ let mut event: NonNull<E> = event.cast();
+ let result: NonNull<Result<()>> = result.cast();
+ let hook: &F = hook.as_ref();
+ let res = hook(event.as_mut());
+ ptr::write(result.as_ptr(), res)
+ }
+
+ unsafe {
+ ErasedHook {
+ data: NonNull::new_unchecked(Box::into_raw(Box::new(hook)) as *mut Opaque),
+ call: call::<E, F>,
+ }
+ }
+ }
+
+ pub(crate) unsafe fn call<E: Event>(&self, event: &mut E) -> Result<()> {
+ let mut res = Ok(());
+
+ unsafe {
+ (self.call)(
+ self.data,
+ NonNull::from(event).cast(),
+ NonNull::from(&mut res).cast(),
+ );
+ }
+ res
+ }
+}
+
+unsafe impl Sync for ErasedHook {}
+unsafe impl Send for ErasedHook {}
diff --git a/helix-event/src/lib.rs b/helix-event/src/lib.rs
index 9c082b93..894de5e8 100644
--- a/helix-event/src/lib.rs
+++ b/helix-event/src/lib.rs
@@ -1,8 +1,203 @@
//! `helix-event` contains systems that allow (often async) communication between
-//! different editor components without strongly coupling them. Currently this
-//! crate only contains some smaller facilities but the intend is to add more
-//! functionality in the future ( like a generic hook system)
+//! different editor components without strongly coupling them. Specifically
+//! it allows defining synchronous hooks that run when certain editor events
+//! occur.
+//!
+//! The core of the event system are hook callbacks and the [`Event`] trait. A
+//! hook is essentially just a closure `Fn(event: &mut impl Event) -> Result<()>`
+//! that gets called every time an appropriate event is dispatched. The implementation
+//! details of the [`Event`] trait are considered private. The [`events`] macro is
+//! provided which automatically declares event types. Similarly the `register_hook`
+//! macro should be used to (safely) declare event hooks.
+//!
+//! Hooks run synchronously which can be advantageous since they can modify the
+//! current editor state right away (for example to immediately hide the completion
+//! popup). However, they can not contain their own state without locking since
+//! they only receive immutable references. For handler that want to track state, do
+//! expensive background computations or debouncing an [`AsyncHook`] is preferable.
+//! Async hooks are based around a channels that receive events specific to
+//! that `AsyncHook` (usually an enum). These events can be sent by synchronous
+//! hooks. Due to some limitations around tokio channels the [`send_blocking`]
+//! function exported in this crate should be used instead of the builtin
+//! `blocking_send`.
+//!
+//! In addition to the core event system, this crate contains some message queues
+//! that allow transfer of data back to the main event loop from async hooks and
+//! hooks that may not have access to all application data (for example in helix-view).
+//! This include the ability to control rendering ([`lock_frame`], [`request_redraw`]) and
+//! display status messages ([`status`]).
+//!
+//! Hooks declared in helix-term can furthermore dispatch synchronous jobs to be run on the
+//! main loop (including access to the compositor). Ideally that queue will be moved
+//! to helix-view in the future if we manage to detach the compositor from its rendering backend.
+use anyhow::Result;
+pub use cancel::{cancelable_future, cancelation, CancelRx, CancelTx};
+pub use debounce::{send_blocking, AsyncHook};
pub use redraw::{lock_frame, redraw_requested, request_redraw, start_frame, RenderLockGuard};
+pub use registry::Event;
+mod cancel;
+mod debounce;
+mod hook;
mod redraw;
+mod registry;
+#[doc(hidden)]
+pub mod runtime;
+pub mod status;
+
+#[cfg(test)]
+mod test;
+
+pub fn register_event<E: Event + 'static>() {
+ registry::with_mut(|registry| registry.register_event::<E>())
+}
+
+/// Registers a hook that will be called when an event of type `E` is dispatched.
+/// This function should usually not be used directly, use the [`register_hook`]
+/// macro instead.
+///
+///
+/// # Safety
+///
+/// `hook` must be totally generic over all lifetime parameters of `E`. For
+/// example if `E` was a known type `Foo<'a, 'b>`, then the correct trait bound
+/// would be `F: for<'a, 'b, 'c> Fn(&'a mut Foo<'b, 'c>)`, but there is no way to
+/// express that kind of constraint for a generic type with the Rust type system
+/// as of this writing.
+pub unsafe fn register_hook_raw<E: Event>(
+ hook: impl Fn(&mut E) -> Result<()> + 'static + Send + Sync,
+) {
+ registry::with_mut(|registry| registry.register_hook(hook))
+}
+
+/// Register a hook solely by event name
+pub fn register_dynamic_hook(
+ hook: impl Fn() -> Result<()> + 'static + Send + Sync,
+ id: &str,
+) -> Result<()> {
+ registry::with_mut(|reg| reg.register_dynamic_hook(hook, id))
+}
+
+pub fn dispatch(e: impl Event) {
+ registry::with(|registry| registry.dispatch(e));
+}
+
+/// Macro to declare events
+///
+/// # Examples
+///
+/// ``` no-compile
+/// events! {
+/// FileWrite(&Path)
+/// ViewScrolled{ view: View, new_pos: ViewOffset }
+/// DocumentChanged<'a> { old_doc: &'a Rope, doc: &'a mut Document, changes: &'a ChangeSet }
+/// }
+///
+/// fn init() {
+/// register_event::<FileWrite>();
+/// register_event::<ViewScrolled>();
+/// register_event::<DocumentChanged>();
+/// }
+///
+/// fn save(path: &Path, content: &str){
+/// std::fs::write(path, content);
+/// dispatch(FileWrite(path));
+/// }
+/// ```
+#[macro_export]
+macro_rules! events {
+ ($name: ident<$($lt: lifetime),*> { $($data:ident : $data_ty:ty),* } $($rem:tt)*) => {
+ pub struct $name<$($lt),*> { $(pub $data: $data_ty),* }
+ unsafe impl<$($lt),*> $crate::Event for $name<$($lt),*> {
+ const ID: &'static str = stringify!($name);
+ const LIFETIMES: usize = $crate::events!(@sum $(1, $lt),*);
+ type Static = $crate::events!(@replace_lt $name, $('static, $lt),*);
+ }
+ $crate::events!{ $($rem)* }
+ };
+ ($name: ident { $($data:ident : $data_ty:ty),* } $($rem:tt)*) => {
+ pub struct $name { $(pub $data: $data_ty),* }
+ unsafe impl $crate::Event for $name {
+ const ID: &'static str = stringify!($name);
+ const LIFETIMES: usize = 0;
+ type Static = Self;
+ }
+ $crate::events!{ $($rem)* }
+ };
+ () => {};
+ (@replace_lt $name: ident, $($lt1: lifetime, $lt2: lifetime),* ) => {$name<$($lt1),*>};
+ (@sum $($val: expr, $lt1: lifetime),* ) => {0 $(+ $val)*};
+}
+
+/// Safely register statically typed event hooks
+#[macro_export]
+macro_rules! register_hook {
+ // Safety: this is safe because we fully control the type of the event here and
+ // ensure all lifetime arguments are fully generic and the correct number of lifetime arguments
+ // is present
+ (move |$event:ident: &mut $event_ty: ident<$($lt: lifetime),*>| $body: expr) => {
+ let val = move |$event: &mut $event_ty<$($lt),*>| $body;
+ unsafe {
+ // Lifetimes are a bit of a pain. We want to allow events being
+ // non-static. Lifetimes don't actually exist at runtime so its
+ // fine to essentially transmute the lifetimes as long as we can
+ // prove soundness. The hook must therefore accept any combination
+ // of lifetimes. In other words fn(&'_ mut Event<'_, '_>) is ok
+ // but examples like fn(&'_ mut Event<'_, 'static>) or fn<'a>(&'a
+ // mut Event<'a, 'a>) are not. To make this safe we use a macro to
+ // forbid the user from specifying lifetimes manually (all lifetimes
+ // specified are always function generics and passed to the event so
+ // lifetimes can't be used multiple times and using 'static causes a
+ // syntax error).
+ //
+ // There is one soundness hole tough: Type Aliases allow
+ // "accidentally" creating these problems. For example:
+ //
+ // type Event2 = Event<'static>.
+ // type Event2<'a> = Event<'a, a>.
+ //
+ // These cases can be caught by counting the number of lifetimes
+ // parameters at the parameter declaration site and then at the hook
+ // declaration site. By asserting the number of lifetime parameters
+ // are equal we can catch all bad type aliases under one assumption:
+ // There are no unused lifetime parameters. Introducing a static
+ // would reduce the number of arguments of the alias by one in the
+ // above example Event2 has zero lifetime arguments while the original
+ // event has one lifetime argument. Similar logic applies to using
+ // a lifetime argument multiple times. The ASSERT below performs a
+ // a compile time assertion to ensure exactly this property.
+ //
+ // With unused lifetime arguments it is still one way to cause unsound code:
+ //
+ // type Event2<'a, 'b> = Event<'a, 'a>;
+ //
+ // However, this case will always emit a compiler warning/cause CI
+ // failures so a user would have to introduce #[allow(unused)] which
+ // is easily caught in review (and a very theoretical case anyway).
+ // If we want to be pedantic we can simply compile helix with
+ // forbid(unused). All of this is just a safety net to prevent
+ // very theoretical misuse. This won't come up in real code (and is
+ // easily caught in review).
+ #[allow(unused)]
+ const ASSERT: () = {
+ if <$event_ty as $crate::Event>::LIFETIMES != 0 + $crate::events!(@sum $(1, $lt),*){
+ panic!("invalid type alias");
+ }
+ };
+ $crate::register_hook_raw::<$crate::events!(@replace_lt $event_ty, $('static, $lt),*)>(val);
+ }
+ };
+ (move |$event:ident: &mut $event_ty: ident| $body: expr) => {
+ let val = move |$event: &mut $event_ty| $body;
+ unsafe {
+ #[allow(unused)]
+ const ASSERT: () = {
+ if <$event_ty as $crate::Event>::LIFETIMES != 0{
+ panic!("invalid type alias");
+ }
+ };
+ $crate::register_hook_raw::<$event_ty>(val);
+ }
+ };
+}
diff --git a/helix-event/src/redraw.rs b/helix-event/src/redraw.rs
index a9915223..8fadb8ae 100644
--- a/helix-event/src/redraw.rs
+++ b/helix-event/src/redraw.rs
@@ -5,16 +5,20 @@ use std::future::Future;
use parking_lot::{RwLock, RwLockReadGuard};
use tokio::sync::Notify;
-/// A `Notify` instance that can be used to (asynchronously) request
-/// the editor the render a new frame.
-static REDRAW_NOTIFY: Notify = Notify::const_new();
-
-/// A `RwLock` that prevents the next frame from being
-/// drawn until an exclusive (write) lock can be acquired.
-/// This allows asynchsonous tasks to acquire `non-exclusive`
-/// locks (read) to prevent the next frame from being drawn
-/// until a certain computation has finished.
-static RENDER_LOCK: RwLock<()> = RwLock::new(());
+use crate::runtime_local;
+
+runtime_local! {
+ /// A `Notify` instance that can be used to (asynchronously) request
+ /// the editor to render a new frame.
+ static REDRAW_NOTIFY: Notify = Notify::const_new();
+
+ /// A `RwLock` that prevents the next frame from being
+ /// drawn until an exclusive (write) lock can be acquired.
+ /// This allows asynchronous tasks to acquire `non-exclusive`
+ /// locks (read) to prevent the next frame from being drawn
+ /// until a certain computation has finished.
+ static RENDER_LOCK: RwLock<()> = RwLock::new(());
+}
pub type RenderLockGuard = RwLockReadGuard<'static, ()>;
diff --git a/helix-event/src/registry.rs b/helix-event/src/registry.rs
new file mode 100644
index 00000000..d43c48ac
--- /dev/null
+++ b/helix-event/src/registry.rs
@@ -0,0 +1,131 @@
+//! A global registry where events are registered and can be
+//! subscribed to by registering hooks. The registry identifies event
+//! types using their type name so multiple event with the same type name
+//! may not be registered (will cause a panic to ensure soundness)
+
+use std::any::TypeId;
+
+use anyhow::{bail, Result};
+use hashbrown::hash_map::Entry;
+use hashbrown::HashMap;
+use parking_lot::RwLock;
+
+use crate::hook::ErasedHook;
+use crate::runtime_local;
+
+pub struct Registry {
+ events: HashMap<&'static str, TypeId, ahash::RandomState>,
+ handlers: HashMap<&'static str, Vec<ErasedHook>, ahash::RandomState>,
+}
+
+impl Registry {
+ pub fn register_event<E: Event + 'static>(&mut self) {
+ let ty = TypeId::of::<E>();
+ assert_eq!(ty, TypeId::of::<E::Static>());
+ match self.events.entry(E::ID) {
+ Entry::Occupied(entry) => {
+ if entry.get() == &ty {
+ // don't warn during tests to avoid log spam
+ #[cfg(not(feature = "integration_test"))]
+ panic!("Event {} was registered multiple times", E::ID);
+ } else {
+ panic!("Multiple events with ID {} were registered", E::ID);
+ }
+ }
+ Entry::Vacant(ent) => {
+ ent.insert(ty);
+ self.handlers.insert(E::ID, Vec::new());
+ }
+ }
+ }
+
+ /// # Safety
+ ///
+ /// `hook` must be totally generic over all lifetime parameters of `E`. For
+ /// example if `E` was a known type `Foo<'a, 'b> then the correct trait bound
+ /// would be `F: for<'a, 'b, 'c> Fn(&'a mut Foo<'b, 'c>)` but there is no way to
+ /// express that kind of constraint for a generic type with the rust type system
+ /// right now.
+ pub unsafe fn register_hook<E: Event>(
+ &mut self,
+ hook: impl Fn(&mut E) -> Result<()> + 'static + Send + Sync,
+ ) {
+ // ensure event type ids match so we can rely on them always matching
+ let id = E::ID;
+ let Some(&event_id) = self.events.get(id) else {
+ panic!("Tried to register handler for unknown event {id}");
+ };
+ assert!(
+ TypeId::of::<E::Static>() == event_id,
+ "Tried to register invalid hook for event {id}"
+ );
+ let hook = ErasedHook::new(hook);
+ self.handlers.get_mut(id).unwrap().push(hook);
+ }
+
+ pub fn register_dynamic_hook(
+ &mut self,
+ hook: impl Fn() -> Result<()> + 'static + Send + Sync,
+ id: &str,
+ ) -> Result<()> {
+ // ensure event type ids match so we can rely on them always matching
+ if self.events.get(id).is_none() {
+ bail!("Tried to register handler for unknown event {id}");
+ };
+ let hook = ErasedHook::new_dynamic(hook);
+ self.handlers.get_mut(id).unwrap().push(hook);
+ Ok(())
+ }
+
+ pub fn dispatch<E: Event>(&self, mut event: E) {
+ let Some(hooks) = self.handlers.get(E::ID) else {
+ log::error!("Dispatched unknown event {}", E::ID);
+ return;
+ };
+ let event_id = self.events[E::ID];
+
+ assert_eq!(
+ TypeId::of::<E::Static>(),
+ event_id,
+ "Tried to dispatch invalid event {}",
+ E::ID
+ );
+
+ for hook in hooks {
+ // safety: event type is the same
+ if let Err(err) = unsafe { hook.call(&mut event) } {
+ log::error!("{} hook failed: {err:#?}", E::ID);
+ crate::status::report_blocking(err);
+ }
+ }
+ }
+}
+
+runtime_local! {
+ static REGISTRY: RwLock<Registry> = RwLock::new(Registry {
+ // hardcoded random number is good enough here we don't care about DOS resistance
+ // and avoids the additional complexity of `Option<Registry>`
+ events: HashMap::with_hasher(ahash::RandomState::with_seeds(423, 9978, 38322, 3280080)),
+ handlers: HashMap::with_hasher(ahash::RandomState::with_seeds(423, 99078, 382322, 3282938)),
+ });
+}
+
+pub(crate) fn with<T>(f: impl FnOnce(&Registry) -> T) -> T {
+ f(&REGISTRY.read())
+}
+
+pub(crate) fn with_mut<T>(f: impl FnOnce(&mut Registry) -> T) -> T {
+ f(&mut REGISTRY.write())
+}
+
+/// # Safety
+/// The number of specified lifetimes and the static type *must* be correct.
+/// This is ensured automatically by the [`events`](crate::events)
+/// macro.
+pub unsafe trait Event: Sized {
+ /// Globally unique (case sensitive) string that identifies this type.
+ /// A good candidate is the events type name
+ const ID: &'static str;
+ const LIFETIMES: usize;
+ type Static: Event + 'static;
+}
diff --git a/helix-event/src/runtime.rs b/helix-event/src/runtime.rs
new file mode 100644
index 00000000..8da465ef
--- /dev/null
+++ b/helix-event/src/runtime.rs
@@ -0,0 +1,88 @@
+//! The event system makes use of global to decouple different systems.
+//! However, this can cause problems for the integration test system because
+//! it runs multiple helix applications in parallel. Making the globals
+//! thread-local does not work because a applications can/does have multiple
+//! runtime threads. Instead this crate implements a similar notion to a thread
+//! local but instead of being local to a single thread, the statics are local to
+//! a single tokio-runtime. The implementation requires locking so it's not exactly efficient.
+//!
+//! Therefore this function is only enabled during integration tests and behaves like
+//! a normal static otherwise. I would prefer this module to be fully private and to only
+//! export the macro but the macro still need to construct these internals so it's marked
+//! `doc(hidden)` instead
+
+use std::ops::Deref;
+
+#[cfg(not(feature = "integration_test"))]
+pub struct RuntimeLocal<T: 'static> {
+ /// inner API used in the macro, not part of public API
+ #[doc(hidden)]
+ pub __data: T,
+}
+
+#[cfg(not(feature = "integration_test"))]
+impl<T> Deref for RuntimeLocal<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.__data
+ }
+}
+
+#[cfg(not(feature = "integration_test"))]
+#[macro_export]
+macro_rules! runtime_local {
+ ($($(#[$attr:meta])* $vis: vis static $name:ident: $ty: ty = $init: expr;)*) => {
+ $($(#[$attr])* $vis static $name: $crate::runtime::RuntimeLocal<$ty> = $crate::runtime::RuntimeLocal {
+ __data: $init
+ };)*
+ };
+}
+
+#[cfg(feature = "integration_test")]
+pub struct RuntimeLocal<T: 'static> {
+ data:
+ parking_lot::RwLock<hashbrown::HashMap<tokio::runtime::Id, &'static T, ahash::RandomState>>,
+ init: fn() -> T,
+}
+
+#[cfg(feature = "integration_test")]
+impl<T> RuntimeLocal<T> {
+ /// inner API used in the macro, not part of public API
+ #[doc(hidden)]
+ pub const fn __new(init: fn() -> T) -> Self {
+ Self {
+ data: parking_lot::RwLock::new(hashbrown::HashMap::with_hasher(
+ ahash::RandomState::with_seeds(423, 9978, 38322, 3280080),
+ )),
+ init,
+ }
+ }
+}
+
+#[cfg(feature = "integration_test")]
+impl<T> Deref for RuntimeLocal<T> {
+ type Target = T;
+ fn deref(&self) -> &T {
+ let id = tokio::runtime::Handle::current().id();
+ let guard = self.data.read();
+ match guard.get(&id) {
+ Some(res) => res,
+ None => {
+ drop(guard);
+ let data = Box::leak(Box::new((self.init)()));
+ let mut guard = self.data.write();
+ guard.insert(id, data);
+ data
+ }
+ }
+ }
+}
+
+#[cfg(feature = "integration_test")]
+#[macro_export]
+macro_rules! runtime_local {
+ ($($(#[$attr:meta])* $vis: vis static $name:ident: $ty: ty = $init: expr;)*) => {
+ $($(#[$attr])* $vis static $name: $crate::runtime::RuntimeLocal<$ty> = $crate::runtime::RuntimeLocal::__new(|| $init);)*
+ };
+}
diff --git a/helix-event/src/status.rs b/helix-event/src/status.rs
new file mode 100644
index 00000000..fdca6762
--- /dev/null
+++ b/helix-event/src/status.rs
@@ -0,0 +1,68 @@
+//! A queue of async messages/errors that will be shown in the editor
+
+use std::borrow::Cow;
+use std::time::Duration;
+
+use crate::{runtime_local, send_blocking};
+use once_cell::sync::OnceCell;
+use tokio::sync::mpsc::{Receiver, Sender};
+
+/// Describes the severity level of a [`StatusMessage`].
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+pub enum Severity {
+ Hint,
+ Info,
+ Warning,
+ Error,
+}
+
+pub struct StatusMessage {
+ pub severity: Severity,
+ pub message: Cow<'static, str>,
+}
+
+impl From<anyhow::Error> for StatusMessage {
+ fn from(err: anyhow::Error) -> Self {
+ StatusMessage {
+ severity: Severity::Error,
+ message: err.to_string().into(),
+ }
+ }
+}
+
+impl From<&'static str> for StatusMessage {
+ fn from(msg: &'static str) -> Self {
+ StatusMessage {
+ severity: Severity::Info,
+ message: msg.into(),
+ }
+ }
+}
+
+runtime_local! {
+ static MESSAGES: OnceCell<Sender<StatusMessage>> = OnceCell::new();
+}
+
+pub async fn report(msg: impl Into<StatusMessage>) {
+ // if the error channel overflows just ignore it
+ let _ = MESSAGES
+ .wait()
+ .send_timeout(msg.into(), Duration::from_millis(10))
+ .await;
+}
+
+pub fn report_blocking(msg: impl Into<StatusMessage>) {
+ let messages = MESSAGES.wait();
+ send_blocking(messages, msg.into())
+}
+
+/// Must be called once during editor startup exactly once
+/// before any of the messages in this module can be used
+///
+/// # Panics
+/// If called multiple times
+pub fn setup() -> Receiver<StatusMessage> {
+ let (tx, rx) = tokio::sync::mpsc::channel(128);
+ let _ = MESSAGES.set(tx);
+ rx
+}
diff --git a/helix-event/src/test.rs b/helix-event/src/test.rs
new file mode 100644
index 00000000..a1283ada
--- /dev/null
+++ b/helix-event/src/test.rs
@@ -0,0 +1,90 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use parking_lot::Mutex;
+
+use crate::{dispatch, events, register_dynamic_hook, register_event, register_hook};
+#[test]
+fn smoke_test() {
+ events! {
+ Event1 { content: String }
+ Event2 { content: usize }
+ }
+ register_event::<Event1>();
+ register_event::<Event2>();
+
+ // setup hooks
+ let res1: Arc<Mutex<String>> = Arc::default();
+ let acc = Arc::clone(&res1);
+ register_hook!(move |event: &mut Event1| {
+ acc.lock().push_str(&event.content);
+ Ok(())
+ });
+ let res2: Arc<AtomicUsize> = Arc::default();
+ let acc = Arc::clone(&res2);
+ register_hook!(move |event: &mut Event2| {
+ acc.fetch_add(event.content, Ordering::Relaxed);
+ Ok(())
+ });
+
+ // triggers events
+ let thread = std::thread::spawn(|| {
+ for i in 0..1000 {
+ dispatch(Event2 { content: i });
+ }
+ });
+ std::thread::sleep(Duration::from_millis(1));
+ dispatch(Event1 {
+ content: "foo".to_owned(),
+ });
+ dispatch(Event2 { content: 42 });
+ dispatch(Event1 {
+ content: "bar".to_owned(),
+ });
+ dispatch(Event1 {
+ content: "hello world".to_owned(),
+ });
+ thread.join().unwrap();
+
+ // check output
+ assert_eq!(&**res1.lock(), "foobarhello world");
+ assert_eq!(
+ res2.load(Ordering::Relaxed),
+ 42 + (0..1000usize).sum::<usize>()
+ );
+}
+
+#[test]
+fn dynamic() {
+ events! {
+ Event3 {}
+ Event4 { count: usize }
+ };
+ register_event::<Event3>();
+ register_event::<Event4>();
+
+ let count = Arc::new(AtomicUsize::new(0));
+ let count1 = count.clone();
+ let count2 = count.clone();
+ register_dynamic_hook(
+ move || {
+ count1.fetch_add(2, Ordering::Relaxed);
+ Ok(())
+ },
+ "Event3",
+ )
+ .unwrap();
+ register_dynamic_hook(
+ move || {
+ count2.fetch_add(3, Ordering::Relaxed);
+ Ok(())
+ },
+ "Event4",
+ )
+ .unwrap();
+ dispatch(Event3 {});
+ dispatch(Event4 { count: 0 });
+ dispatch(Event3 {});
+ assert_eq!(count.load(Ordering::Relaxed), 7)
+}