feat: WTF-8 validator (#3374)

Author: sxyazi

Cargo.lock

@@ -48,12 +48,12 @@ impl Refresh {
 
 	// TODO: performance improvement
 	fn trigger_dirs(folders: &[&Folder]) {
-		async fn go(cwd: UrlBuf, cha: Cha) {
-			let Some(cha) = Files::assert_stale(&cwd, cha).await else { return };
+		async fn go(dir: UrlBuf, cha: Cha) {
+			let Some(cha) = Files::assert_stale(&dir, cha).await else { return };
 
-			match Files::from_dir_bulk(&cwd).await {
-				Ok(files) => FilesOp::Full(cwd, files, cha).emit(),
-				Err(e) => FilesOp::issue_error(&cwd, e).await,
+			match Files::from_dir_bulk(&dir).await {
+				Ok(files) => FilesOp::Full(dir, files, cha).emit(),
+				Err(e) => FilesOp::issue_error(&dir, e).await,
 			}
 		}
 

yazi-actor/src/mgr/refresh.rs

@@ -21,7 +21,6 @@ clap      = { workspace = true }
 futures   = { workspace = true }
 hashbrown = { workspace = true }
 regex     = { workspace = true }
-serde     = { workspace = true }
 
 [build-dependencies]
 yazi-shared = { path = "../yazi-shared", version = "25.9.15" }

yazi-boot/Cargo.toml

@@ -59,7 +59,7 @@ tokio-stream = { workspace = true }
 
 # Logging
 tracing            = { workspace = true }
-tracing-appender   = "0.2.3"
+tracing-appender   = "0.2.4"
 tracing-subscriber = { version = "0.3.20", features = [ "env-filter" ] }
 
 [target."cfg(unix)".dependencies]

yazi-fm/Cargo.toml

@@ -32,6 +32,7 @@ scopeguard       = { workspace = true }
 serde            = { workspace = true }
 tokio            = { workspace = true }
 tracing          = { workspace = true }
+typed-path       = { workspace = true }
 
 [target."cfg(unix)".dependencies]
 libc  = { workspace = true }

yazi-fs/Cargo.toml

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, path::PathBuf};
 
-use yazi_shared::{FromWtf8Vec, loc::LocBuf, path::{PathBufDyn, PathCow, PathDyn, PathKind, PathLike}, pool::InternStr, url::{AsUrl, Url, UrlBuf, UrlCow, UrlLike}};
+use yazi_shared::{loc::LocBuf, path::{PathBufDyn, PathCow, PathDyn, PathKind, PathLike}, pool::InternStr, url::{AsUrl, Url, UrlBuf, UrlCow, UrlLike}, wtf8::FromWtf8Vec};
 
 use crate::{CWD, path::clean_url};
 
@@ -25,21 +25,25 @@ fn expand_url_impl<'a>(url: Url<'a>) -> UrlCow<'a> {
 	let mut path = PathBufDyn::with_capacity(url.kind(), n_base.len() + n_rest.len() + n_urn.len());
 	path.try_extend([n_base, n_rest, n_urn]).expect("extend original parts should not fail");
 
-	let loc = LocBuf::<PathBuf>::with(
-		path.into_os().expect("Failed to convert PathBufDyn to PathBuf"),
-		(uri_count + rest_diff + urn_diff) as usize,
-		(urn_count + urn_diff) as usize,
-	)
-	.expect("Failed to create Loc from expanded path");
+	let uri = (uri_count + rest_diff + urn_diff) as usize;
+	let urn = (urn_count + urn_diff) as usize;
 
 	let expanded = match url {
-		Url::Regular(_) => UrlBuf::Regular(loc),
-		Url::Search { domain, .. } => UrlBuf::Search { loc, domain: domain.intern() },
-		Url::Archive { domain, .. } => UrlBuf::Archive { loc, domain: domain.intern() },
-		Url::Sftp { domain, .. } => {
-			todo!();
-			// UrlBuf::Sftp { loc, domain: domain.intern() }
-		}
+		Url::Regular(_) => UrlBuf::Regular(
+			LocBuf::<std::path::PathBuf>::with(path.into_os().unwrap(), uri, urn).unwrap(),
+		),
+		Url::Search { domain, .. } => UrlBuf::Search {
+			loc:    LocBuf::<std::path::PathBuf>::with(path.into_os().unwrap(), uri, urn).unwrap(),
+			domain: domain.intern(),
+		},
+		Url::Archive { domain, .. } => UrlBuf::Archive {
+			loc:    LocBuf::<std::path::PathBuf>::with(path.into_os().unwrap(), uri, urn).unwrap(),
+			domain: domain.intern(),
+		},
+		Url::Sftp { domain, .. } => UrlBuf::Sftp {
+			loc:    LocBuf::<typed_path::UnixPathBuf>::with(path.into_unix().unwrap(), uri, urn).unwrap(),
+			domain: domain.intern(),
+		},
 	};
 
 	absolute_url(expanded)

yazi-fs/src/path/expand.rs

@@ -1,45 +1,32 @@
 use std::{borrow::Cow, path::{Path, PathBuf}};
 
+use anyhow::Result;
 use percent_encoding::{AsciiSet, CONTROLS, percent_decode, percent_encode};
-use yazi_shared::path::PathDyn;
+use yazi_shared::path::{PathCow, PathDyn, PathKind};
 
 const SET: &AsciiSet =
 	&CONTROLS.add(b'"').add(b'*').add(b':').add(b'<').add(b'>').add(b'?').add(b'\\').add(b'|');
 
-pub trait PercentEncoding {
-	fn percent_encode(&self) -> Cow<'_, Path>;
+pub trait PercentEncoding<'a> {
+	fn percent_encode(self) -> Cow<'a, Path>;
 
-	fn percent_decode(&self) -> Cow<'_, [u8]>;
+	fn percent_decode<K>(self, kind: K) -> Result<PathCow<'a>>
+	where
+		K: Into<PathKind>;
 }
 
-impl PercentEncoding for Path {
-	fn percent_encode(&self) -> Cow<'_, Path> {
-		match percent_encode(self.as_os_str().as_encoded_bytes(), SET).into() {
-			Cow::Borrowed(_) => self.into(),
+impl<'a> PercentEncoding<'a> for PathDyn<'a> {
+	fn percent_encode(self) -> Cow<'a, Path> {
+		match percent_encode(self.encoded_bytes(), SET).into() {
+			Cow::Borrowed(s) => Path::new(s).into(),
 			Cow::Owned(s) => PathBuf::from(s).into(),
 		}
 	}
 
-	fn percent_decode(&self) -> Cow<'_, [u8]> {
-		match percent_decode(self.as_os_str().as_encoded_bytes()).into() {
-			Cow::Borrowed(_) => self.as_os_str().as_encoded_bytes().into(),
-			Cow::Owned(s) => s.into(),
-		}
-	}
-}
-
-impl PercentEncoding for PathDyn<'_> {
-	fn percent_encode(&self) -> Cow<'_, Path> {
-		match self {
-			PathDyn::Os(p) => p.percent_encode(),
-			PathDyn::Unix(_) => todo!(),
-		}
-	}
-
-	fn percent_decode(&self) -> Cow<'_, [u8]> {
-		match self {
-			PathDyn::Os(p) => p.percent_decode(),
-			PathDyn::Unix(_) => todo!(),
-		}
+	fn percent_decode<K>(self, kind: K) -> Result<PathCow<'a>>
+	where
+		K: Into<PathKind>,
+	{
+		PathCow::with(kind, percent_decode(self.encoded_bytes()))
 	}
 }

yazi-fs/src/path/percent.rs

@@ -1,8 +1,8 @@
 use std::{borrow::Cow, ffi::OsStr, path::{Path, PathBuf}};
 
-use yazi_shared::{path::PathDyn, url::{AsUrl, Url, UrlBuf, UrlCow}};
+use yazi_shared::{path::{AsPath, PathDyn}, url::{AsUrl, Url, UrlBuf, UrlCow}};
 
-use crate::{FsHash128, FsScheme};
+use crate::{FsHash128, FsScheme, path::PercentEncoding};
 
 pub trait FsUrl<'a> {
 	fn cache(&self) -> Option<PathBuf>;
@@ -26,13 +26,12 @@ impl<'a> FsUrl<'a> for Url<'a> {
 	fn cache(&self) -> Option<PathBuf> {
 		fn with_loc(loc: PathDyn, mut root: PathBuf) -> PathBuf {
 			let mut it = loc.components();
-			todo!();
-			// if it.next() == Some(std::path::Component::RootDir) {
-			// 	root.push(it.as_path().percent_encode());
-			// } else {
-			// 	root.push(".%2F");
-			// 	root.push(loc.percent_encode());
-			// }
+			if it.next() == Some(yazi_shared::path::Component::RootDir) {
+				root.push(it.as_path().percent_encode());
+			} else {
+				root.push(".%2F");
+				root.push(loc.percent_encode());
+			}
 			root
 		}
 

yazi-fs/src/url.rs

@@ -3,7 +3,7 @@ use std::{any::TypeId, ffi::OsStr, io, process::Stdio};
 use mlua::{AnyUserData, ExternalError, IntoLuaMulti, Lua, MetaMethod, Table, UserData, Value};
 use tokio::process::{ChildStderr, ChildStdin, ChildStdout};
 use yazi_binding::Error;
-use yazi_shared::FromWtf8;
+use yazi_shared::wtf8::FromWtf8;
 
 use super::{Child, output::Output};
 use crate::process::Status;

yazi-plugin/src/process/command.rs

@@ -1,8 +1,8 @@
 #![allow(clippy::option_map_unit_fn)]
 
-yazi_macro::mod_pub!(data errors event loc path pool scheme shell strand translit url);
+yazi_macro::mod_pub!(data errors event loc path pool scheme shell strand translit url wtf8);
 
-yazi_macro::mod_flat!(alias bytes chars condition debounce either env id layer natsort os predictor ro_cell source sync_cell terminal tests throttle time utf8 wtf8);
+yazi_macro::mod_flat!(alias bytes chars condition debounce either env id layer natsort os predictor ro_cell source sync_cell terminal tests throttle time utf8);
 
 pub fn init() {
 	pool::init();