Files
luxe/crates/luxe-lsp/src/uri.rs
Evan Whittaker 09a7de2520 Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
2026-10-17 12:08:30 -05:00

129 lines
5.5 KiB
Rust

//! uri — the `file://` URIs the language-server protocol speaks, and the paths behind them.
//!
//! Build and take apart these URIs here, never with `format!("file://{}", …)` or
//! `strip_prefix("file://")`. That works for one shape of path only: an absolute unix path with no
//! character a URI reserves. On Windows it produces `file://C:\src\main.rs`, whose authority is
//! `C:` and whose path is nothing, which every server rejects or misresolves; and on every platform
//! an unencoded space or `#` (`C:\Program Files`, `~/My Notes`) truncates the path.
//!
//! The correct spelling is `file:///C:/src/main.rs` with percent-encoding, and `url` knows all of
//! it (drive letters, UNC shares, the encoding table), so this is a thin wrapper around it.
use std::path::{Path, PathBuf};
use url::Url;
/// The `file://` URI for an absolute path.
///
/// A relative path has no URI, and a server would reject one anyway; rather than refuse mid-request
/// it degrades to the naive spelling with forward slashes, which is what every caller did before and
/// is at least parseable by the [`to_path`] on the other side.
pub(crate) fn from_path(path: &Path) -> String {
match Url::from_file_path(path) {
Ok(url) => url.into(),
Err(()) => format!("file://{}", luxe_core::paths::display(path)),
}
}
/// The path a `file://` URI names.
///
/// Lenient on the way back: servers are inconsistent about encoding (VS Code sends `file:///c%3A/`,
/// others send `file:///C:/`), and some send a bare path where a URI was expected. Anything that
/// does not parse as a URI is treated as a path already.
pub(crate) fn to_path(uri: &str) -> PathBuf {
if let Ok(url) = Url::parse(uri) {
if url.scheme() == "file" {
if let Ok(path) = url.to_file_path() {
return path;
}
}
}
PathBuf::from(uri.strip_prefix("file://").unwrap_or(uri))
}
/// The path a `file://` URI names, rendered for display with forward slashes.
fn to_display_path(uri: &str) -> String {
luxe_core::paths::display(&to_path(uri))
}
/// The last two path segments of a URI — enough to recognize a file, short enough for a result row.
pub(crate) fn short_display(uri: &str) -> String {
let path = to_display_path(uri);
let parts: Vec<&str> = path.rsplit('/').take(2).collect();
match parts.as_slice() {
[file, parent] => format!("{parent}/{file}"),
_ => path,
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
/// A URI is not `"file://" + the path`. Three authorities' worth of difference: the empty one
/// after `file://`, the encoding, and (on Windows) the leading slash before the drive.
#[test]
fn a_uri_round_trips_back_to_the_path_it_came_from() {
let path = if cfg!(windows) {
PathBuf::from(r"C:\projects\luxe\src\main.rs")
} else {
PathBuf::from("/projects/luxe/src/main.rs")
};
let uri = from_path(&path);
assert!(uri.starts_with("file:///"), "three slashes, empty authority: {uri}");
assert!(!uri.contains('\\'), "a URI has no backslashes: {uri}");
assert_eq!(to_path(&uri), path);
}
/// The bug that was live on every platform, not just Windows: a space is not a URI character,
/// and an unencoded one truncates the path at the server.
#[test]
fn reserved_characters_are_encoded_and_decode_back() {
let path = if cfg!(windows) {
PathBuf::from(r"C:\Program Files\my app\a b#c.rs")
} else {
PathBuf::from("/opt/Program Files/my app/a b#c.rs")
};
let uri = from_path(&path);
assert!(!uri.contains(' '), "spaces are encoded: {uri}");
assert!(uri.contains("%20"), "{uri}");
assert_eq!(to_path(&uri), path, "and survive the trip back");
}
/// Servers disagree about how to spell a drive letter; both readings have to work.
#[cfg(windows)]
#[test]
fn either_spelling_of_a_drive_letter_is_understood() {
let expected = PathBuf::from(r"C:\src\main.rs");
assert_eq!(to_path("file:///C:/src/main.rs"), expected);
assert_eq!(to_path("file:///c%3A/src/main.rs"), expected);
}
/// Some servers answer with a bare path where the protocol says URI. Treat it as a path rather
/// than losing the location.
#[test]
fn a_bare_path_is_accepted_where_a_uri_was_expected() {
let bare = if cfg!(windows) { r"C:\src\main.rs" } else { "/src/main.rs" };
assert_eq!(to_path(bare), PathBuf::from(bare));
}
#[test]
fn a_display_path_uses_forward_slashes_whatever_the_platform() {
let path = if cfg!(windows) { r"C:\src\main.rs" } else { "/src/main.rs" };
let rendered = to_display_path(&from_path(Path::new(path)));
assert!(!rendered.contains('\\'), "{rendered}");
assert!(rendered.ends_with("/src/main.rs"), "{rendered}");
}
/// A result row shows the file and its directory — decoded, so a path with a space reads as one
/// rather than as `%20`. The fixtures carry a drive letter on Windows because a URI without one
/// names no file there, and `Url` rightly refuses to invent it.
#[test]
fn a_short_display_keeps_two_segments_and_decodes_them() {
let root = if cfg!(windows) { "file:///C:" } else { "file://" };
assert_eq!(short_display(&format!("{root}/a/b/c/main.rs")), "c/main.rs");
assert_eq!(short_display(&format!("{root}/my%20app/main.rs")), "my app/main.rs");
assert_eq!(short_display("main.rs"), "main.rs", "nothing to shorten");
}
}