rust/crates/vfs/src/vfs_path.rs

422 lines
14 KiB
Rust
Raw Normal View History

2020-06-15 06:29:07 -05:00
//! Abstract-ish representation of paths for VFS.
use std::fmt;
use paths::{AbsPath, AbsPathBuf, RelPath};
2020-06-15 06:29:07 -05:00
2021-01-12 10:22:57 -06:00
/// Path in [`Vfs`].
///
2020-06-15 06:29:07 -05:00
/// Long-term, we want to support files which do not reside in the file-system,
2021-01-12 10:22:57 -06:00
/// so we treat `VfsPath`s as opaque identifiers.
///
/// [`Vfs`]: crate::Vfs
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
2020-06-15 06:29:07 -05:00
pub struct VfsPath(VfsPathRepr);
impl VfsPath {
2021-01-12 10:22:57 -06:00
/// Creates an "in-memory" path from `/`-separated string.
///
2020-06-11 04:04:09 -05:00
/// This is most useful for testing, to avoid windows/linux differences
2021-01-12 10:22:57 -06:00
///
/// # Panics
///
/// Panics if `path` does not start with `'/'`.
2020-06-11 04:04:09 -05:00
pub fn new_virtual_path(path: String) -> VfsPath {
assert!(path.starts_with('/'));
VfsPath(VfsPathRepr::VirtualPath(VirtualPath(path)))
}
2021-10-01 08:07:11 -05:00
/// Create a path from string. Input should be a string representation of
/// an absolute path inside filesystem
pub fn new_real_path(path: String) -> VfsPath {
VfsPath::from(AbsPathBuf::assert(path.into()))
}
2021-01-12 10:22:57 -06:00
/// Returns the `AbsPath` representation of `self` if `self` is on the file system.
2020-06-15 06:29:07 -05:00
pub fn as_path(&self) -> Option<&AbsPath> {
match &self.0 {
VfsPathRepr::PathBuf(it) => Some(it.as_path()),
2020-06-11 04:04:09 -05:00
VfsPathRepr::VirtualPath(_) => None,
2020-06-15 06:29:07 -05:00
}
}
2021-01-12 10:22:57 -06:00
/// Creates a new `VfsPath` with `path` adjoined to `self`.
2020-06-26 09:25:08 -05:00
pub fn join(&self, path: &str) -> Option<VfsPath> {
2020-06-15 06:29:07 -05:00
match &self.0 {
VfsPathRepr::PathBuf(it) => {
let res = it.join(path).normalize();
2020-06-26 09:25:08 -05:00
Some(VfsPath(VfsPathRepr::PathBuf(res)))
2020-06-15 06:29:07 -05:00
}
2020-06-11 04:04:09 -05:00
VfsPathRepr::VirtualPath(it) => {
2020-06-26 09:25:08 -05:00
let res = it.join(path)?;
Some(VfsPath(VfsPathRepr::VirtualPath(res)))
2020-06-11 04:04:09 -05:00
}
2020-06-15 06:29:07 -05:00
}
}
2021-01-12 10:22:57 -06:00
/// Remove the last component of `self` if there is one.
///
/// If `self` has no component, returns `false`; else returns `true`.
///
/// # Example
///
/// ```
/// # use vfs::{AbsPathBuf, VfsPath};
/// let mut path = VfsPath::from(AbsPathBuf::assert("/foo/bar".into()));
/// assert!(path.pop());
/// assert_eq!(path, VfsPath::from(AbsPathBuf::assert("/foo".into())));
/// assert!(path.pop());
/// assert_eq!(path, VfsPath::from(AbsPathBuf::assert("/".into())));
/// assert!(!path.pop());
/// ```
2020-06-15 06:29:07 -05:00
pub fn pop(&mut self) -> bool {
match &mut self.0 {
VfsPathRepr::PathBuf(it) => it.pop(),
2020-06-11 04:04:09 -05:00
VfsPathRepr::VirtualPath(it) => it.pop(),
}
}
2021-01-12 10:22:57 -06:00
/// Returns `true` if `other` is a prefix of `self`.
2020-06-11 04:04:09 -05:00
pub fn starts_with(&self, other: &VfsPath) -> bool {
match (&self.0, &other.0) {
(VfsPathRepr::PathBuf(lhs), VfsPathRepr::PathBuf(rhs)) => lhs.starts_with(rhs),
(VfsPathRepr::VirtualPath(lhs), VfsPathRepr::VirtualPath(rhs)) => lhs.starts_with(rhs),
2021-10-03 07:45:08 -05:00
(VfsPathRepr::PathBuf(_) | VfsPathRepr::VirtualPath(_), _) => false,
2020-06-15 06:29:07 -05:00
}
}
2021-01-12 10:22:57 -06:00
pub fn strip_prefix(&self, other: &VfsPath) -> Option<&RelPath> {
match (&self.0, &other.0) {
(VfsPathRepr::PathBuf(lhs), VfsPathRepr::PathBuf(rhs)) => lhs.strip_prefix(rhs),
(VfsPathRepr::VirtualPath(lhs), VfsPathRepr::VirtualPath(rhs)) => lhs.strip_prefix(rhs),
(VfsPathRepr::PathBuf(_) | VfsPathRepr::VirtualPath(_), _) => None,
}
}
2021-01-12 10:22:57 -06:00
/// Returns the `VfsPath` without its final component, if there is one.
///
/// Returns [`None`] if the path is a root or prefix.
2020-09-03 18:25:00 -05:00
pub fn parent(&self) -> Option<VfsPath> {
let mut parent = self.clone();
if parent.pop() {
Some(parent)
} else {
None
2020-09-03 17:32:06 -05:00
}
}
2020-07-07 15:53:12 -05:00
2021-01-12 10:22:57 -06:00
/// Returns `self`'s base name and file extension.
pub fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
2020-09-03 15:18:23 -05:00
match &self.0 {
2020-09-03 17:32:06 -05:00
VfsPathRepr::PathBuf(p) => Some((
p.file_stem()?.to_str()?,
p.extension().and_then(|extension| extension.to_str()),
)),
VfsPathRepr::VirtualPath(p) => p.name_and_extension(),
2020-09-03 15:18:23 -05:00
}
}
2021-01-12 10:41:45 -06:00
/// **Don't make this `pub`**
///
/// Encode the path in the given buffer.
///
/// The encoding will be `0` if [`AbsPathBuf`], `1` if [`VirtualPath`], followed
/// by `self`'s representation.
///
/// Note that this encoding is dependent on the operating system.
2020-07-07 15:53:12 -05:00
pub(crate) fn encode(&self, buf: &mut Vec<u8>) {
let tag = match &self.0 {
VfsPathRepr::PathBuf(_) => 0,
VfsPathRepr::VirtualPath(_) => 1,
};
buf.push(tag);
match &self.0 {
2020-08-13 18:19:46 -05:00
VfsPathRepr::PathBuf(path) => {
2020-07-07 15:53:12 -05:00
#[cfg(windows)]
{
2020-08-13 18:19:46 -05:00
use windows_paths::Encode;
2021-07-17 08:43:33 -05:00
let path: &std::path::Path = path.as_ref();
2020-08-13 18:19:46 -05:00
let components = path.components();
let mut add_sep = false;
for component in components {
if add_sep {
windows_paths::SEP.encode(buf);
}
let len_before = buf.len();
match component {
std::path::Component::Prefix(prefix) => {
// kind() returns a normalized and comparable path prefix.
prefix.kind().encode(buf);
}
std::path::Component::RootDir => {
if !add_sep {
component.as_os_str().encode(buf);
}
}
_ => component.as_os_str().encode(buf),
}
// some components may be encoded empty
add_sep = len_before != buf.len();
2020-07-07 15:53:12 -05:00
}
}
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
2020-08-13 18:19:46 -05:00
buf.extend(path.as_os_str().as_bytes());
2020-07-07 15:53:12 -05:00
}
#[cfg(not(any(windows, unix)))]
{
2020-08-13 18:19:46 -05:00
buf.extend(path.as_os_str().to_string_lossy().as_bytes());
2020-07-07 15:53:12 -05:00
}
}
VfsPathRepr::VirtualPath(VirtualPath(s)) => buf.extend(s.as_bytes()),
}
}
2020-06-15 06:29:07 -05:00
}
2020-08-13 18:19:46 -05:00
#[cfg(windows)]
mod windows_paths {
2020-11-02 09:31:38 -06:00
pub(crate) trait Encode {
2020-08-13 18:19:46 -05:00
fn encode(&self, buf: &mut Vec<u8>);
}
impl Encode for std::ffi::OsStr {
fn encode(&self, buf: &mut Vec<u8>) {
use std::os::windows::ffi::OsStrExt;
for wchar in self.encode_wide() {
buf.extend(wchar.to_le_bytes().iter().copied());
}
}
}
impl Encode for u8 {
fn encode(&self, buf: &mut Vec<u8>) {
let wide = *self as u16;
buf.extend(wide.to_le_bytes().iter().copied())
}
}
impl Encode for &str {
fn encode(&self, buf: &mut Vec<u8>) {
debug_assert!(self.is_ascii());
for b in self.as_bytes() {
b.encode(buf)
}
}
}
2020-11-02 09:31:38 -06:00
pub(crate) const SEP: &str = "\\";
2020-08-13 18:19:46 -05:00
const VERBATIM: &str = "\\\\?\\";
const UNC: &str = "UNC";
const DEVICE: &str = "\\\\.\\";
const COLON: &str = ":";
impl Encode for std::path::Prefix<'_> {
fn encode(&self, buf: &mut Vec<u8>) {
match self {
std::path::Prefix::Verbatim(c) => {
VERBATIM.encode(buf);
c.encode(buf);
}
std::path::Prefix::VerbatimUNC(server, share) => {
VERBATIM.encode(buf);
UNC.encode(buf);
SEP.encode(buf);
server.encode(buf);
SEP.encode(buf);
share.encode(buf);
}
std::path::Prefix::VerbatimDisk(d) => {
VERBATIM.encode(buf);
d.encode(buf);
COLON.encode(buf);
}
std::path::Prefix::DeviceNS(device) => {
DEVICE.encode(buf);
device.encode(buf);
}
std::path::Prefix::UNC(server, share) => {
SEP.encode(buf);
SEP.encode(buf);
server.encode(buf);
SEP.encode(buf);
share.encode(buf);
}
std::path::Prefix::Disk(d) => {
d.encode(buf);
COLON.encode(buf);
}
}
}
}
#[test]
fn paths_encoding() {
// drive letter casing agnostic
test_eq("C:/x.rs", "c:/x.rs");
// separator agnostic
test_eq("C:/x/y.rs", "C:\\x\\y.rs");
fn test_eq(a: &str, b: &str) {
let mut b1 = Vec::new();
let mut b2 = Vec::new();
vfs(a).encode(&mut b1);
vfs(b).encode(&mut b2);
assert_eq!(b1, b2);
}
}
#[test]
fn test_sep_root_dir_encoding() {
let mut buf = Vec::new();
vfs("C:/x/y").encode(&mut buf);
assert_eq!(&buf, &[0, 67, 0, 58, 0, 92, 0, 120, 0, 92, 0, 121, 0])
}
#[cfg(test)]
fn vfs(str: &str) -> super::VfsPath {
use super::{AbsPathBuf, VfsPath};
VfsPath::from(AbsPathBuf::try_from(str).unwrap())
}
}
2021-01-12 10:41:45 -06:00
/// Internal, private representation of [`VfsPath`].
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
2020-06-15 06:29:07 -05:00
enum VfsPathRepr {
PathBuf(AbsPathBuf),
2020-06-11 04:04:09 -05:00
VirtualPath(VirtualPath),
2020-06-15 06:29:07 -05:00
}
impl From<AbsPathBuf> for VfsPath {
fn from(v: AbsPathBuf) -> Self {
2020-06-11 04:04:09 -05:00
VfsPath(VfsPathRepr::PathBuf(v.normalize()))
2020-06-15 06:29:07 -05:00
}
}
impl fmt::Display for VfsPath {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.0 {
VfsPathRepr::PathBuf(it) => fmt::Display::fmt(&it.display(), f),
2020-06-11 04:04:09 -05:00
VfsPathRepr::VirtualPath(VirtualPath(it)) => fmt::Display::fmt(it, f),
}
}
}
impl fmt::Debug for VfsPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.0, f)
}
}
impl fmt::Debug for VfsPathRepr {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self {
VfsPathRepr::PathBuf(it) => fmt::Debug::fmt(&it.display(), f),
VfsPathRepr::VirtualPath(VirtualPath(it)) => fmt::Debug::fmt(&it, f),
}
}
}
2021-01-12 10:41:45 -06:00
/// `/`-separated virtual path.
///
/// This is used to describe files that do not reside on the file system.
2020-06-11 04:04:09 -05:00
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
struct VirtualPath(String);
impl VirtualPath {
2021-01-12 10:41:45 -06:00
/// Returns `true` if `other` is a prefix of `self` (as strings).
2020-06-11 04:04:09 -05:00
fn starts_with(&self, other: &VirtualPath) -> bool {
self.0.starts_with(&other.0)
}
2021-01-12 10:41:45 -06:00
fn strip_prefix(&self, base: &VirtualPath) -> Option<&RelPath> {
<_ as AsRef<std::path::Path>>::as_ref(&self.0)
.strip_prefix(&base.0)
.ok()
.map(RelPath::new_unchecked)
}
2021-01-12 10:41:45 -06:00
/// Remove the last component of `self`.
///
/// This will find the last `'/'` in `self`, and remove everything after it,
/// including the `'/'`.
///
/// If `self` contains no `'/'`, returns `false`; else returns `true`.
///
/// # Example
///
/// ```rust,ignore
/// let mut path = VirtualPath("/foo/bar".to_string());
/// path.pop();
/// assert_eq!(path.0, "/foo");
/// path.pop();
/// assert_eq!(path.0, "");
/// ```
2020-06-11 04:04:09 -05:00
fn pop(&mut self) -> bool {
let pos = match self.0.rfind('/') {
Some(pos) => pos,
None => return false,
};
self.0 = self.0[..pos].to_string();
true
}
2021-01-12 10:41:45 -06:00
/// Append the given *relative* path `path` to `self`.
///
/// This will resolve any leading `"../"` in `path` before appending it.
///
/// Returns [`None`] if `path` has more leading `"../"` than the number of
/// components in `self`.
///
/// # Notes
///
/// In practice, appending here means `self/path` as strings.
2020-06-26 09:25:08 -05:00
fn join(&self, mut path: &str) -> Option<VirtualPath> {
2020-06-11 04:04:09 -05:00
let mut res = self.clone();
while path.starts_with("../") {
2020-06-26 09:25:08 -05:00
if !res.pop() {
return None;
}
path = &path["../".len()..];
2020-06-15 06:29:07 -05:00
}
path = path.trim_start_matches("./");
res.0 = format!("{}/{path}", res.0);
2020-06-26 09:25:08 -05:00
Some(res)
2020-06-15 06:29:07 -05:00
}
2020-09-03 15:18:23 -05:00
2021-01-12 10:41:45 -06:00
/// Returns `self`'s base name and file extension.
///
/// # Returns
/// - `None` if `self` ends with `"//"`.
/// - `Some((name, None))` if `self`'s base contains no `.`, or only one `.` at
/// the start.
/// - `Some((name, Some(extension))` else.
///
/// # Note
/// The extension will not contains `.`. This means `"/foo/bar.baz.rs"` will
/// return `Some(("bar.baz", Some("rs"))`.
fn name_and_extension(&self) -> Option<(&str, Option<&str>)> {
2020-09-07 18:42:45 -05:00
let file_path = if self.0.ends_with('/') { &self.0[..&self.0.len() - 1] } else { &self.0 };
let file_name = match file_path.rfind('/') {
Some(position) => &file_path[position + 1..],
None => file_path,
};
if file_name.is_empty() {
None
} else {
let mut file_stem_and_extension = file_name.rsplitn(2, '.');
let extension = file_stem_and_extension.next();
let file_stem = file_stem_and_extension.next();
match (file_stem, extension) {
(None, None) => None,
2021-06-17 10:37:14 -05:00
(None | Some(""), Some(_)) => Some((file_name, None)),
(Some(file_stem), extension) => Some((file_stem, extension)),
}
}
2020-09-03 15:18:23 -05:00
}
2020-06-15 06:29:07 -05:00
}
2020-09-07 18:42:45 -05:00
#[cfg(test)]
mod tests;