turbo_unix_path/

lib.rs

#![doc = include_str!("../README.md")]

use std::borrow::Cow;

use smallvec::SmallVec;

/// Converts system paths into Unix paths. This is a noop on Unix systems, and replaces backslash
/// directory separators with forward slashes on Windows.
#[inline]
pub fn sys_to_unix(path: &str) -> Cow<'_, str> {
    #[cfg(not(windows))]
    {
        Cow::from(path)
    }
    #[cfg(windows)]
    {
        Cow::Owned(path.replace(std::path::MAIN_SEPARATOR_STR, "/"))
    }
}

/// Converts Unix paths into system paths. This is a noop on Unix systems, and replaces forward
/// slash directory separators with backslashes on Windows.
#[inline]
pub fn unix_to_sys(path: &str) -> Cow<'_, str> {
    #[cfg(not(windows))]
    {
        Cow::from(path)
    }
    #[cfg(windows)]
    {
        Cow::Owned(path.replace('/', std::path::MAIN_SEPARATOR_STR))
    }
}

/// Joins two /-separated paths into a normalized path.
/// Paths are concatenated with /.
///
/// see also [normalize_path] for normalization.
/// Returns `None` if the joined path would leave the filesystem root.
pub fn join_path(fs_path: &str, join: &str) -> Option<String> {
    debug_assert!(
        !cfg!(windows) || !join.contains('\\'),
        "joined path {join} must not contain a Windows directory '\\', it must be normalized to \
         Unix '/'"
    );

    // TODO: figure out why this freezes the benchmarks.
    // // an absolute path would leave the file system root
    // if Path::new(join).is_absolute() {
    //     return None;
    // }

    if fs_path.is_empty() {
        normalize_path(join)
    } else if join.is_empty() {
        normalize_path(fs_path)
    } else {
        normalize_path(&[fs_path, "/", join].concat())
    }
}

/// Normalizes a /-separated path into a form that contains no leading /, no double /, no "."
/// segment, no ".." segment.
///
/// Returns None if the path would need to start with ".." to be equal.
pub fn normalize_path(str: &str) -> Option<String> {
    let mut segments = SmallVec::<[&str; 8]>::new();
    for segment in str.split('/') {
        match segment {
            "." | "" => {}
            ".." => {
                segments.pop()?;
            }
            segment => {
                segments.push(segment);
            }
        }
    }
    Some(segments.join("/"))
}

/// Normalizes a /-separated request into a form that contains no leading /, no double /, and no "."
/// or ".." segments in the middle of the request.
///
/// A request might only start with a single "." segment and no ".." segments, or any positive
/// number of ".." segments but no "." segment.
pub fn normalize_request(str: &str) -> String {
    let mut segments = SmallVec::<[&str; 8]>::new();
    segments.push(".");
    // Keeps track of our directory depth so that we can pop directories when encountering a "..".
    // If this is positive, then we're inside a directory and we can pop that. If it's 0, then we
    // can't pop the directory and we must keep the ".." in our segments. This is not the same as
    // the segments.len(), because we cannot pop a kept ".." when encountering another "..".
    let mut depth = 0;
    let mut popped_dot = false;
    for segment in str.split('/') {
        match segment {
            "." => {}
            ".." => {
                if depth > 0 {
                    depth -= 1;
                    segments.pop();
                } else {
                    // The first time we push a "..", we need to remove the "." we include by
                    // default.
                    if !popped_dot {
                        popped_dot = true;
                        segments.pop();
                    }
                    segments.push(segment);
                }
            }
            segment => {
                segments.push(segment);
                depth += 1;
            }
        }
    }
    segments.join("/")
}

/// Returns the path of `target` relative to `from`, as a plain path: `"c"`, `"../c"`, or `"."` when
/// the two are equal.
///
/// The result is not prefixed with `./`, so it is a path and not a module request. Use
/// [`get_relative_request_to`] to build an import specifier, where a bare `"c"` would be read as a
/// package name rather than as a file next to `from`.
///
/// Returns `"."` by reference when the paths are identical, or `target` by reference when `from`
/// is empty.
pub fn get_relative_path_to<'a>(from: &str, target: &'a str) -> Cow<'a, str> {
    if from.is_empty() && !target.is_empty() {
        return Cow::Borrowed(target);
    }

    relative_to(from, target, false)
}

/// Returns the path of `target` relative to `from`, as an explicitly relative module request:
/// `"./c"`, `"../c"`, or `"."` when the two are equal.
///
/// The `./` prefix is what makes the result a relative request: without it, `"c"` resolves as the
/// package `c` instead of the file `c` next to `from`. Use [`get_relative_path_to`] when a plain
/// path is wanted instead.
///
/// Returns `"."` by reference when the paths are identical.
pub fn get_relative_request_to<'a>(from: &str, target: &'a str) -> Cow<'a, str> {
    relative_to(from, target, true)
}

/// Shared by [`get_relative_path_to`] and [`get_relative_request_to`]; `explicitly_relative` adds
/// the leading `./` that distinguishes a request from a path.
fn relative_to<'a>(from: &str, target: &'a str, explicitly_relative: bool) -> Cow<'a, str> {
    fn split(s: &str) -> impl Iterator<Item = &str> {
        let mut iterator = s.split('/');
        if s.is_empty() {
            iterator.next();
        }
        iterator
    }

    let mut from_segments = split(from).peekable();
    let mut target_segments = split(target).peekable();
    while from_segments.peek() == target_segments.peek() {
        from_segments.next();
        if target_segments.next().is_none() {
            return Cow::Borrowed(".");
        }
    }
    let mut result = SmallVec::<[&str; 8]>::new();
    if from_segments.peek().is_some() {
        while from_segments.next().is_some() {
            result.push("..");
        }
    } else if explicitly_relative {
        // Nothing to walk up, so the path would be bare (`c`) without this.
        result.push(".");
    }
    for segment in target_segments {
        result.push(segment);
    }
    Cow::Owned(result.join("/"))
}

pub fn get_parent_path(path: &str) -> &str {
    match str::rfind(path, '/') {
        Some(index) => &path[..index],
        None => "",
    }
}

#[cfg(test)]
mod tests {

    use rstest::*;

    use super::*;

    #[rstest]
    #[case("file.js")]
    #[case("a/b/c/d/e/file.js")]
    fn test_normalize_path_no_op(#[case] path: &str) {
        assert_eq!(path, normalize_path(path).unwrap());
    }

    #[rstest]
    #[case("/file.js", "file.js")]
    #[case("./file.js", "file.js")]
    #[case("././file.js", "file.js")]
    #[case("a/../c/../file.js", "file.js")]
    fn test_normalize_path(#[case] path: &str, #[case] normalized: &str) {
        assert_eq!(normalized, normalize_path(path).unwrap());
    }

    #[rstest]
    #[case("../file.js")]
    #[case("a/../../file.js")]
    fn test_normalize_path_invalid(#[case] path: &str) {
        assert_eq!(None, normalize_path(path));
    }

    #[rstest]
    #[case("a/b/c", "a/b/c", ".", true)]
    #[case("a/c/d", "a/b/c", "../../b/c", false)]
    #[case("", "a/b/c", "a/b/c", true)]
    #[case("", "", ".", true)]
    #[case("a/b", "a/b/c", "c", false)]
    #[case("a/b/c", "", "../../..", false)]
    #[case("a/b/c", "c/b/a", "../../../c/b/a", false)]
    #[case("file:///a/b/c", "file:///c/b/a", "../../../c/b/a", false)]
    fn test_get_relative_path_to(
        #[case] from: &str,
        #[case] target: &str,
        #[case] expected: &str,
        #[case] borrowed: bool,
    ) {
        let relative = get_relative_path_to(from, target);
        assert_eq!(relative, expected);
        assert_eq!(matches!(relative, Cow::Borrowed(_)), borrowed);
    }

    /// The same cases as [`test_get_relative_path_to`], so the two forms can be compared row by
    /// row. They differ only where the result would otherwise be a bare path, which is exactly
    /// where a request needs its `./`.
    #[rstest]
    #[case("a/b/c", "a/b/c", ".", true)]
    #[case("a/c/d", "a/b/c", "../../b/c", false)]
    #[case("", "a/b/c", "./a/b/c", false)]
    #[case("", "", ".", true)]
    #[case("a/b", "a/b/c", "./c", false)]
    #[case("a/b", "a/b/c/d", "./c/d", false)]
    #[case("a/b/c", "", "../../..", false)]
    #[case("a/b/c", "c/b/a", "../../../c/b/a", false)]
    #[case("file:///a/b/c", "file:///c/b/a", "../../../c/b/a", false)]
    fn test_get_relative_request_to(
        #[case] from: &str,
        #[case] target: &str,
        #[case] expected: &str,
        #[case] borrowed: bool,
    ) {
        let relative = get_relative_request_to(from, target);
        assert_eq!(relative, expected);
        assert_eq!(matches!(relative, Cow::Borrowed(_)), borrowed);
    }
}