refactor: simplify paths (#3297)

Author: sxyazi

yazi-actor/src/cmp/trigger.rs

@@ -1,11 +1,11 @@
-use std::{ffi::OsString, mem, path::MAIN_SEPARATOR_STR};
+use std::{ffi::OsString, mem, path::{MAIN_SEPARATOR_STR, PathBuf}};
 
 use anyhow::Result;
 use yazi_fs::{CWD, path::expand_url, provider::{DirReader, FileHolder}};
 use yazi_macro::{act, render, succ};
 use yazi_parser::cmp::{CmpItem, ShowOpt, TriggerOpt};
 use yazi_proxy::CmpProxy;
-use yazi_shared::{OsStrSplit, data::Data, natsort, scheme::SchemeLike, url::{UrlBuf, UrlCow, UrnBuf}};
+use yazi_shared::{OsStrSplit, data::Data, natsort, scheme::SchemeLike, url::{UrlBuf, UrlCow}};
 use yazi_vfs::provider;
 
 use crate::{Actor, Ctx};
@@ -67,7 +67,7 @@ impl Actor for Trigger {
 }
 
 impl Trigger {
-	fn split_url(s: &str) -> Option<(UrlBuf, UrnBuf)> {
+	fn split_url(s: &str) -> Option<(UrlBuf, PathBuf)> {
 		let (scheme, path, ..) = UrlCow::parse(s.as_bytes()).ok()?;
 
 		if scheme.is_local() && path.as_os_str() == "~" {
@@ -91,16 +91,16 @@ impl Trigger {
 
 #[cfg(test)]
 mod tests {
-	use yazi_shared::url::{UrlLike, Urn};
+	use yazi_shared::url::UrlLike;
 
 	use super::*;
 
 	fn compare(s: &str, parent: &str, child: &str) {
 		let (mut p, c) = Trigger::split_url(s).unwrap();
 		if let Some(u) = p.strip_prefix(yazi_fs::CWD.load().as_ref()) {
-			p = UrlBuf::from(&**u);
+			p = UrlBuf::from(u);
 		}
-		assert_eq!((p, c.as_urn()), (parent.parse().unwrap(), Urn::new(child)));
+		assert_eq!((p, c.to_str().unwrap()), (parent.parse().unwrap(), child));
 	}
 
 	#[cfg(unix)]

yazi-binding/src/url.rs

@@ -4,7 +4,7 @@ use mlua::{AnyUserData, ExternalError, FromLua, Lua, MetaMethod, UserData, UserD
 use yazi_fs::{FsHash64, FsHash128};
 use yazi_shared::{IntoOsStr, scheme::SchemeLike, url::{AsUrl, UrlCow, UrlLike}};
 
-use crate::{Scheme, Urn, cached_field, deprecate};
+use crate::{Scheme, cached_field, deprecate};
 
 pub type UrlRef = UserDataRef<Url>;
 
@@ -108,7 +108,10 @@ impl UserData for Url {
 			me.ext().map(|s| lua.create_string(s.as_encoded_bytes())).transpose()
 		});
 		cached_field!(fields, parent, |_, me| Ok(me.parent().map(Self::new)));
-		cached_field!(fields, urn, |_, me| Ok(Urn::new(me.urn())));
+		cached_field!(fields, urn, |_, me| {
+			// FIXME: remove type inference
+			Ok(super::Path::<std::path::PathBuf>::new(me.urn()))
+		});
 		cached_field!(fields, base, |_, me| Ok(me.base().map(Self::new)));
 
 		cached_field!(fields, scheme, |_, me| Ok(Scheme::new(&me.scheme)));

yazi-binding/src/urn.rs

@@ -3,43 +3,34 @@ use std::{ops::Deref, path::PathBuf};
 use mlua::{ExternalError, FromLua, Lua, UserData, Value};
 use yazi_shared::path::PathBufLike;
 
-pub struct Urn<P: PathBufLike = PathBuf> {
-	inner: yazi_shared::url::UrnBuf<P>,
-}
+pub struct Path<P: PathBufLike = PathBuf>(pub P);
 
-impl<P> Deref for Urn<P>
+impl<P> Deref for Path<P>
 where
 	P: PathBufLike,
 {
-	type Target = yazi_shared::url::UrnBuf<P>;
-
-	fn deref(&self) -> &Self::Target { &self.inner }
-}
+	type Target = P;
 
-impl<P> From<Urn<P>> for yazi_shared::url::UrnBuf<P>
-where
-	P: PathBufLike,
-{
-	fn from(value: Urn<P>) -> Self { value.inner }
+	fn deref(&self) -> &Self::Target { &self.0 }
 }
 
-impl<P> Urn<P>
+impl<P> Path<P>
 where
 	P: PathBufLike,
 {
-	pub fn new(urn: impl Into<yazi_shared::url::UrnBuf<P>>) -> Self { Self { inner: urn.into() } }
+	pub fn new(urn: impl Into<P>) -> Self { Self(urn.into()) }
 }
 
-impl<P> FromLua for Urn<P>
+impl<P> FromLua for Path<P>
 where
 	P: PathBufLike,
 {
 	fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
 		Ok(match value {
 			Value::UserData(ud) => ud.take()?,
-			_ => Err("Expected a Urn".into_lua_err())?,
+			_ => Err("Expected a Path".into_lua_err())?,
 		})
 	}
 }
 
-impl<P> UserData for Urn<P> where P: PathBufLike {}
+impl<P> UserData for Path<P> where P: PathBufLike {}

yazi-boot/src/boot.rs

@@ -4,13 +4,13 @@ use futures::executor::block_on;
 use hashbrown::HashSet;
 use serde::Serialize;
 use yazi_fs::{CWD, Xdg, path::expand_url};
-use yazi_shared::url::{UrlBuf, UrlCow, UrlLike, UrnBuf};
+use yazi_shared::url::{UrlBuf, UrlCow, UrlLike};
 use yazi_vfs::provider;
 
 #[derive(Debug, Default, Serialize)]
 pub struct Boot {
 	pub cwds:  Vec<UrlBuf>,
-	pub files: Vec<UrnBuf>,
+	pub files: Vec<PathBuf>,
 
 	pub local_events:  HashSet<String>,
 	pub remote_events: HashSet<String>,
@@ -22,25 +22,25 @@ pub struct Boot {
 }
 
 impl Boot {
-	async fn parse_entries(entries: &[UrlBuf]) -> (Vec<UrlBuf>, Vec<UrnBuf>) {
+	async fn parse_entries(entries: &[UrlBuf]) -> (Vec<UrlBuf>, Vec<PathBuf>) {
 		if entries.is_empty() {
-			return (vec![CWD.load().as_ref().clone()], vec![UrnBuf::default()]);
+			return (vec![CWD.load().as_ref().clone()], vec![PathBuf::default()]);
 		}
 
-		async fn go(entry: &UrlBuf) -> (UrlBuf, UrnBuf) {
+		async fn go(entry: &UrlBuf) -> (UrlBuf, PathBuf) {
 			let mut entry = expand_url(entry);
 			if let Ok(u @ UrlCow::Owned { .. }) = provider::absolute(&entry).await {
 				entry = u.into_owned();
 			}
 
 			let Some((parent, child)) = entry.pair() else {
-				return (entry, UrnBuf::default());
+				return (entry, PathBuf::default());
 			};
 
 			if provider::metadata(&entry).await.is_ok_and(|m| m.is_file()) {
 				(parent.into(), child.to_owned())
 			} else {
-				(entry, UrnBuf::default())
+				(entry, PathBuf::default())
 			}
 		}
 

yazi-core/src/tab/finder.rs

@@ -1,13 +1,15 @@
+use std::path::{Path, PathBuf};
+
 use anyhow::Result;
 use hashbrown::HashMap;
 use yazi_fs::{Files, Filter, FilterCase};
-use yazi_shared::url::{UrlBuf, Urn, UrnBuf};
+use yazi_shared::url::UrlBuf;
 
 use crate::tab::Folder;
 
 pub struct Finder {
 	pub filter:  Filter,
-	pub matched: HashMap<UrnBuf, u8>,
+	pub matched: HashMap<PathBuf, u8>,
 	lock:        FinderLock,
 }
 
@@ -76,7 +78,7 @@ impl Finder {
 }
 
 impl Finder {
-	pub fn matched_idx(&self, folder: &Folder, urn: &Urn) -> Option<u8> {
+	pub fn matched_idx(&self, folder: &Folder, urn: &Path) -> Option<u8> {
 		if self.lock == *folder { self.matched.get(urn).copied() } else { None }
 	}
 }

yazi-core/src/tab/folder.rs

@@ -1,12 +1,12 @@
-use std::mem;
+use std::{mem, path::{Path, PathBuf}};
 
 use yazi_config::{LAYOUT, YAZI};
 use yazi_dds::Pubsub;
 use yazi_fs::{File, Files, FilesOp, FolderStage, cha::Cha};
 use yazi_macro::err;
 use yazi_parser::Step;
 use yazi_proxy::MgrProxy;
-use yazi_shared::{Id, url::{UrlBuf, Urn, UrnBuf}};
+use yazi_shared::{Id, url::UrlBuf};
 use yazi_widgets::Scrollable;
 
 pub struct Folder {
@@ -19,7 +19,7 @@ pub struct Folder {
 	pub cursor: usize,
 
 	pub page:  usize,
-	pub trace: Option<UrnBuf>,
+	pub trace: Option<PathBuf>,
 }
 
 impl Default for Folder {
@@ -108,7 +108,7 @@ impl Folder {
 		b
 	}
 
-	pub fn hover(&mut self, urn: &Urn) -> bool {
+	pub fn hover(&mut self, urn: &Path) -> bool {
 		if self.hovered().map(|h| h.urn()) == Some(urn) {
 			return self.arrow(0);
 		}
@@ -117,7 +117,7 @@ impl Folder {
 		self.arrow(new - self.cursor as isize)
 	}
 
-	pub fn repos(&mut self, urn: Option<&Urn>) -> bool {
+	pub fn repos(&mut self, urn: Option<&Path>) -> bool {
 		if let Some(u) = urn {
 			self.hover(u)
 		} else if let Some(u) = &self.trace {

yazi-dds/src/sendable.rs

@@ -46,8 +46,8 @@ impl Sendable {
 				Some(t) if t == TypeId::of::<yazi_binding::Url>() => {
 					Data::Url(ud.take::<yazi_binding::Url>()?.into())
 				}
-				Some(t) if t == TypeId::of::<yazi_binding::Urn>() => {
-					Data::Urn(ud.take::<yazi_binding::Urn>()?.into())
+				Some(t) if t == TypeId::of::<yazi_binding::Path<std::path::PathBuf>>() => {
+					Data::Path(ud.take::<yazi_binding::Path<std::path::PathBuf>>()?.0)
 				}
 				Some(t) if t == TypeId::of::<yazi_binding::Id>() => {
 					Data::Id(**ud.borrow::<yazi_binding::Id>()?)
@@ -83,7 +83,7 @@ impl Sendable {
 				Value::Table(tbl)
 			}
 			Data::Url(u) => yazi_binding::Url::new(u).into_lua(lua)?,
-			Data::Urn(u) => yazi_binding::Urn::new(u).into_lua(lua)?,
+			Data::Path(u) => yazi_binding::Path::<std::path::PathBuf>::new(u).into_lua(lua)?,
 			Data::Any(a) => {
 				if a.is::<yazi_fs::FilesOp>() {
 					lua.create_any_userdata(*a.downcast::<yazi_fs::FilesOp>().unwrap())?.into_lua(lua)?
@@ -121,7 +121,7 @@ impl Sendable {
 			}
 			Data::Id(i) => yazi_binding::Id(*i).into_lua(lua)?,
 			Data::Url(u) => yazi_binding::Url::new(u.clone()).into_lua(lua)?,
-			Data::Urn(u) => yazi_binding::Urn::new(u.clone()).into_lua(lua)?,
+			Data::Path(u) => yazi_binding::Path::<std::path::PathBuf>::new(u).into_lua(lua)?,
 			Data::Bytes(b) => Value::String(lua.create_string(b)?),
 			Data::Any(a) => {
 				if let Some(t) = a.downcast_ref::<yazi_fs::FilesOp>() {
@@ -214,8 +214,8 @@ impl Sendable {
 				Some(t) if t == TypeId::of::<yazi_binding::Url>() => {
 					DataKey::Url(ud.take::<yazi_binding::Url>()?.into())
 				}
-				Some(t) if t == TypeId::of::<yazi_binding::Urn>() => {
-					DataKey::Urn(ud.take::<yazi_binding::Urn>()?.into())
+				Some(t) if t == TypeId::of::<yazi_binding::Path>() => {
+					DataKey::Path(ud.take::<yazi_binding::Path>()?.0)
 				}
 				Some(t) if t == TypeId::of::<yazi_binding::Id>() => {
 					DataKey::Id(**ud.borrow::<yazi_binding::Id>()?)
@@ -230,7 +230,7 @@ impl Sendable {
 	fn key_to_value(lua: &Lua, key: DataKey) -> mlua::Result<Value> {
 		match key {
 			DataKey::Url(u) => yazi_binding::Url::new(u).into_lua(lua),
-			DataKey::Urn(u) => yazi_binding::Urn::new(u).into_lua(lua),
+			DataKey::Path(u) => yazi_binding::Path::<std::path::PathBuf>::new(u).into_lua(lua),
 			_ => Self::key_to_value_ref(lua, &key),
 		}
 	}
@@ -244,7 +244,7 @@ impl Sendable {
 			DataKey::String(s) => Value::String(lua.create_string(s.as_ref())?),
 			DataKey::Id(i) => yazi_binding::Id(*i).into_lua(lua)?,
 			DataKey::Url(u) => yazi_binding::Url::new(u.clone()).into_lua(lua)?,
-			DataKey::Urn(u) => yazi_binding::Urn::new(u.clone()).into_lua(lua)?,
+			DataKey::Path(u) => yazi_binding::Path::<std::path::PathBuf>::new(u).into_lua(lua)?,
 			DataKey::Bytes(b) => Value::String(lua.create_string(b)?),
 		})
 	}

yazi-fs/src/cha/cha.rs

@@ -59,6 +59,8 @@ impl Cha {
 		let mut kind = ChaKind::DUMMY;
 		let mode = r#type.map(ChaMode::from_bare).unwrap_or_default();
 
+		#[cfg(unix)]
+		use yazi_shared::path::PathLike;
 		#[cfg(unix)]
 		if _url.as_url().urn().is_hidden() {
 			kind |= ChaKind::HIDDEN;

yazi-fs/src/file.rs

@@ -1,6 +1,6 @@
 use std::{ffi::OsStr, hash::{Hash, Hasher}, ops::Deref, path::{Path, PathBuf}};
 
-use yazi_shared::url::{Uri, UrlBuf, UrlLike, Urn};
+use yazi_shared::url::{UrlBuf, UrlLike};
 
 use crate::cha::{Cha, ChaType};
 
@@ -37,10 +37,10 @@ impl File {
 	pub fn url_owned(&self) -> UrlBuf { self.url.to_owned() }
 
 	#[inline]
-	pub fn uri(&self) -> &Uri { self.url.uri() }
+	pub fn uri(&self) -> &Path { self.url.uri() }
 
 	#[inline]
-	pub fn urn(&self) -> &Urn { self.url.urn() }
+	pub fn urn(&self) -> &Path { self.url.urn() }
 
 	#[inline]
 	pub fn name(&self) -> Option<&OsStr> { self.url.name() }