refactor: switch to actor model (#2986)

Author: sxyazi

Cargo.lock

@@ -0,0 +1,39 @@
+[package]
+name        = "yazi-actor"
+version     = "25.6.11"
+edition     = "2024"
+license     = "MIT"
+authors     = [ "sxyazi <[email protected]>" ]
+description = "Yazi actor model"
+homepage    = "https://yazi-rs.github.io"
+repository  = "https://github.com/sxyazi/yazi"
+
+[dependencies]
+yazi-boot    = { path = "../yazi-boot", version = "25.6.11" }
+yazi-config  = { path = "../yazi-config", version = "25.6.11" }
+yazi-core    = { path = "../yazi-core", version = "25.6.11" }
+yazi-dds     = { path = "../yazi-dds", version = "25.6.11" }
+yazi-fs      = { path = "../yazi-fs", version = "25.6.11" }
+yazi-macro   = { path = "../yazi-macro", version = "25.6.11" }
+yazi-parser  = { path = "../yazi-parser", version = "25.6.11" }
+yazi-plugin  = { path = "../yazi-plugin", version = "25.6.11" }
+yazi-proxy   = { path = "../yazi-proxy", version = "25.6.11" }
+yazi-shared  = { path = "../yazi-shared", version = "25.6.11" }
+yazi-term    = { path = "../yazi-term", version = "25.6.11" }
+yazi-widgets = { path = "../yazi-widgets", version = "25.6.11" }
+
+# External dependencies
+anyhow       = { workspace = true }
+crossterm    = { workspace = true }
+futures      = { workspace = true }
+paste        = { workspace = true }
+scopeguard   = { workspace = true }
+tokio        = { workspace = true }
+tokio-stream = { workspace = true }
+tracing      = { workspace = true }
+
+[target."cfg(unix)".dependencies]
+libc = { workspace = true }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+crossterm = { workspace = true, features = [ "use-dev-tty", "libc" ] }

yazi-actor/Cargo.toml

@@ -0,0 +1,12 @@
+use anyhow::Result;
+use yazi_shared::event::Data;
+
+use crate::Ctx;
+
+pub trait Actor {
+	type Options;
+
+	const NAME: &'static str;
+
+	fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data>;
+}

yazi-actor/src/actor.rs

@@ -0,0 +1,19 @@
+use anyhow::Result;
+use yazi_macro::{render, succ};
+use yazi_parser::ArrowOpt;
+use yazi_shared::event::Data;
+use yazi_widgets::Scrollable;
+
+use crate::{Actor, Ctx};
+
+pub struct Arrow;
+
+impl Actor for Arrow {
+	type Options = ArrowOpt;
+
+	const NAME: &'static str = "arrow";
+
+	fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
+		succ!(render!(cx.cmp.scroll(opt.step)));
+	}
+}

yazi-actor/src/cmp/arrow.rs

@@ -0,0 +1,26 @@
+use std::mem;
+
+use anyhow::Result;
+use yazi_macro::{act, render, succ};
+use yazi_parser::{cmp::CloseOpt, input::CompleteOpt};
+use yazi_shared::event::Data;
+
+use crate::{Actor, Ctx};
+
+pub struct Close;
+
+impl Actor for Close {
+	type Options = CloseOpt;
+
+	const NAME: &'static str = "close";
+
+	fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
+		let cmp = &mut cx.core.cmp;
+		if let Some(item) = cmp.selected().filter(|_| opt.submit).cloned() {
+			return act!(complete, cx.core.input, CompleteOpt { item, _ticket: cmp.ticket });
+		}
+
+		cmp.caches.clear();
+		succ!(render!(mem::replace(&mut cmp.visible, false)));
+	}
+}

yazi-actor/src/cmp/close.rs

@@ -1,40 +1,49 @@
 use std::{mem, ops::ControlFlow};
 
-use yazi_macro::render;
+use anyhow::Result;
+use yazi_macro::{render, succ};
 use yazi_parser::cmp::ShowOpt;
 use yazi_proxy::options::CmpItem;
-use yazi_shared::{osstr_contains, osstr_starts_with};
+use yazi_shared::{event::Data, osstr_contains, osstr_starts_with};
 
-use crate::cmp::Cmp;
+use crate::{Actor, Ctx};
 
 const LIMIT: usize = 30;
 
-impl Cmp {
-	#[yazi_codegen::command]
-	pub fn show(&mut self, opt: ShowOpt) {
-		if self.ticket != opt.ticket {
-			return;
+pub struct Show;
+
+impl Actor for Show {
+	type Options = ShowOpt;
+
+	const NAME: &'static str = "show";
+
+	fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
+		let cmp = &mut cx.cmp;
+		if cmp.ticket != opt.ticket {
+			succ!();
 		}
 
 		if !opt.cache.is_empty() {
-			self.caches.insert(opt.cache_name.clone(), opt.cache);
+			cmp.caches.insert(opt.cache_name.clone(), opt.cache);
 		}
-		let Some(cache) = self.caches.get(&opt.cache_name) else {
-			return;
+		let Some(cache) = cmp.caches.get(&opt.cache_name) else {
+			succ!();
 		};
 
-		self.ticket = opt.ticket;
-		self.cands = Self::match_candidates(&opt.word, cache);
-		if self.cands.is_empty() {
-			return render!(mem::replace(&mut self.visible, false));
+		cmp.ticket = opt.ticket;
+		cmp.cands = Self::match_candidates(&opt.word, cache);
+		if cmp.cands.is_empty() {
+			succ!(render!(mem::replace(&mut cmp.visible, false)));
 		}
 
-		self.offset = 0;
-		self.cursor = 0;
-		self.visible = true;
-		render!();
+		cmp.offset = 0;
+		cmp.cursor = 0;
+		cmp.visible = true;
+		succ!(render!());
 	}
+}
 
+impl Show {
 	fn match_candidates(word: &str, cache: &[CmpItem]) -> Vec<CmpItem> {
 		let smart = !word.bytes().any(|c| c.is_ascii_uppercase());
 

yazi-core/src/cmp/commands/mod.rs renamed to yazi-actor/src/cmp/mod.rs

@@ -1,38 +1,41 @@
 use std::{ffi::OsString, mem, path::{MAIN_SEPARATOR_STR, Path, PathBuf}};
 
+use anyhow::Result;
 use tokio::fs;
 use yazi_fs::{CWD, expand_path};
-use yazi_macro::{emit, render};
-use yazi_parser::cmp::TriggerOpt;
+use yazi_macro::{act, emit, render, succ};
+use yazi_parser::cmp::{ShowOpt, TriggerOpt};
 use yazi_proxy::options::CmpItem;
-use yazi_shared::{event::Cmd, natsort};
+use yazi_shared::{event::{Cmd, Data}, natsort};
 
-use crate::cmp::Cmp;
+use crate::{Actor, Ctx};
 
-impl Cmp {
-	#[yazi_codegen::command]
-	pub fn trigger(&mut self, opt: TriggerOpt) {
+pub struct Trigger;
+
+impl Actor for Trigger {
+	type Options = TriggerOpt;
+
+	const NAME: &'static str = "trigger";
+
+	fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
+		let cmp = &mut cx.cmp;
 		if let Some(t) = opt.ticket {
-			if t < self.ticket {
-				return;
+			if t < cmp.ticket {
+				succ!();
 			}
-			self.ticket = t;
+			cmp.ticket = t;
 		}
 
 		let Some((parent, word)) = Self::split_path(&opt.word) else {
-			return self.close(false);
+			return act!(cmp:close, cx, false);
 		};
 
-		if self.caches.contains_key(&parent) {
-			return self.show(
-				Cmd::default()
-					.with_any("cache-name", parent)
-					.with("word", word)
-					.with("ticket", self.ticket),
-			);
+		if cmp.caches.contains_key(&parent) {
+			let ticket = cmp.ticket;
+			return act!(cmp:show, cx, ShowOpt { cache_name: parent, word: word.into(), ticket, ..Default::default() });
 		}
 
-		let ticket = self.ticket;
+		let ticket = cmp.ticket;
 		tokio::spawn(async move {
 			let mut dir = fs::read_dir(&parent).await?;
 			let mut cache = vec![];
@@ -65,9 +68,11 @@ impl Cmp {
 			Ok::<_, anyhow::Error>(())
 		});
 
-		render!(mem::replace(&mut self.visible, false));
+		succ!(render!(mem::replace(&mut cmp.visible, false)));
 	}
+}
 
+impl Trigger {
 	fn split_path(s: &str) -> Option<(PathBuf, String)> {
 		if s == "~" {
 			return None; // We don't autocomplete a `~`, but `~/`
@@ -93,7 +98,7 @@ mod tests {
 	use super::*;
 
 	fn compare(s: &str, parent: &str, child: &str) {
-		let (p, c) = Cmp::split_path(s).unwrap();
+		let (p, c) = Trigger::split_path(s).unwrap();
 		let p = p.strip_prefix(yazi_fs::CWD.load().as_ref()).unwrap_or(&p);
 		assert_eq!((p, c.as_str()), (Path::new(parent), child));
 	}