use rkyv::{Archive, Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Archive, Serialize, Deserialize)]
pub enum AddressKind {
#[default]
Http,
File,
Data,
GraphshellClip,
Directory,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, Archive, Serialize, Deserialize)]
#[rkyv(derive(Debug, PartialEq))]
pub enum Address {
Http(String),
File(String),
Data(String),
Clip(String),
Directory(String),
Custom(String),
}
impl Address {
pub fn as_url_str(&self) -> &str {
match self {
Address::Http(s)
| Address::File(s)
| Address::Data(s)
| Address::Directory(s)
| Address::Custom(s)
| Address::Clip(s) => s.as_str(),
}
}
pub fn address_kind(&self) -> AddressKind {
match self {
Address::Http(_) => AddressKind::Http,
Address::File(_) => AddressKind::File,
Address::Data(_) => AddressKind::Data,
Address::Clip(_) => AddressKind::GraphshellClip,
Address::Directory(_) => AddressKind::Directory,
Address::Custom(_) => AddressKind::Unknown,
}
}
}
impl chartulary::ContainerAddress for Address {
fn to_address(&self) -> chartulary::Address {
chartulary::Address::new(self.as_url_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Archive, Serialize, Deserialize)]
#[rkyv(derive(Debug, PartialEq))]
pub enum AddressRole {
Primary,
Alias,
}
#[derive(Debug, Clone, PartialEq, Eq, Archive, Serialize, Deserialize)]
#[rkyv(derive(Debug, PartialEq))]
pub struct AddressClaim {
pub address: Address,
pub role: AddressRole,
}
impl AddressClaim {
pub fn primary(address: Address) -> Self {
Self {
address,
role: AddressRole::Primary,
}
}
pub fn alias(address: Address) -> Self {
Self {
address,
role: AddressRole::Alias,
}
}
pub fn is_primary(&self) -> bool {
matches!(self.role, AddressRole::Primary)
}
}
pub fn address_from_url(url: &str) -> Address {
let lower = url.to_ascii_lowercase();
if lower.starts_with("http://") || lower.starts_with("https://") {
Address::Http(url.to_owned())
} else if lower.starts_with("data:") {
Address::Data(url.to_owned())
} else if lower.starts_with("verso://clip/") || lower.starts_with("graphshell://clip/") {
Address::Clip(url.to_owned())
} else if lower.starts_with("file://") {
if file_url_uses_directory_syntax(url) {
Address::Directory(url.to_owned())
} else {
Address::File(url.to_owned())
}
} else {
Address::Custom(url.to_owned())
}
}
pub fn address_kind_from_url(url: &str) -> AddressKind {
let lower = url.to_ascii_lowercase();
if lower.starts_with("http://") || lower.starts_with("https://") {
AddressKind::Http
} else if lower.starts_with("data:") {
AddressKind::Data
} else if lower.starts_with("verso://clip/") || lower.starts_with("graphshell://clip/") {
AddressKind::GraphshellClip
} else if lower.starts_with("file://") {
if file_url_uses_directory_syntax(url) {
AddressKind::Directory
} else {
AddressKind::File
}
} else {
AddressKind::Unknown
}
}
fn file_url_uses_directory_syntax(url: &str) -> bool {
url::Url::parse(url)
.ok()
.is_some_and(|parsed| parsed.path().ends_with('/'))
}
pub fn cached_host_from_url(url: &str) -> Option<String> {
url::Url::parse(url)
.ok()
.and_then(|parsed| parsed.host_str().map(str::to_owned))
}
pub fn detect_mime(url: &str, content_bytes: Option<&[u8]>) -> Option<String> {
let no_fragment = url.split('#').next().unwrap_or(url);
let no_query = no_fragment.split('?').next().unwrap_or(no_fragment);
let path = no_query
.strip_prefix("file://")
.unwrap_or(no_query)
.trim_start_matches('/');
let guess_path = format!("/{path}");
let guessed: Vec<String> = mime_guess::from_path(&guess_path)
.into_iter()
.map(|m| m.to_string())
.collect();
let is_ambiguous = guessed.len() > 1
|| guessed
.first()
.map(|m| m == "application/octet-stream")
.unwrap_or(false);
if !guessed.is_empty() && !is_ambiguous {
return guessed.first().cloned();
}
if let Some(bytes) = content_bytes {
if let Some(kind) = infer::get(bytes) {
return Some(kind.mime_type().to_string());
}
}
guessed.first().cloned()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detect_mime_returns_pdf_for_pdf_path() {
assert_eq!(
detect_mime("file:///home/user/document.pdf", None),
Some("application/pdf".to_string())
);
}
#[test]
fn detect_mime_returns_text_plain_for_txt_path() {
assert_eq!(
detect_mime("file:///notes/readme.txt", None),
Some("text/plain".to_string())
);
}
#[test]
fn detect_mime_returns_none_for_no_extension() {
assert!(detect_mime("https://example.com/page", None).is_none());
}
#[test]
fn detect_mime_uses_magic_bytes_when_extension_is_missing() {
let pdf_header = b"%PDF-1.7\n1 0 obj\n";
assert_eq!(
detect_mime("https://example.com/no-extension", Some(pdf_header)),
Some("application/pdf".to_string())
);
}
#[test]
fn detect_mime_prefers_extension_when_unambiguous() {
let pdf_header = b"%PDF-1.7\n1 0 obj\n";
assert_eq!(
detect_mime("file:///home/user/readme.txt", Some(pdf_header)),
Some("text/plain".to_string())
);
}
#[test]
fn detect_mime_falls_back_to_extension_when_magic_unknown() {
let unknown = b"not a known magic signature";
assert_eq!(
detect_mime("file:///home/user/data.json", Some(unknown)),
Some("application/json".to_string())
);
}
#[test]
fn address_kind_from_url_http() {
assert_eq!(
address_kind_from_url("http://example.com"),
AddressKind::Http
);
assert_eq!(
address_kind_from_url("https://example.com"),
AddressKind::Http
);
}
#[test]
fn address_kind_from_url_file() {
assert_eq!(
address_kind_from_url("file:///home/user/file.txt"),
AddressKind::File
);
}
#[test]
fn address_kind_from_url_data_clip_directory_and_unknown() {
assert_eq!(
address_kind_from_url("data:text/plain,hello"),
AddressKind::Data
);
assert_eq!(
address_kind_from_url("verso://clip/clip-123"),
AddressKind::GraphshellClip
);
assert_eq!(
address_kind_from_url("file:///tmp/sample-dir/"),
AddressKind::Directory
);
assert_eq!(
address_kind_from_url("gemini://gemini.circumlunar.space/"),
AddressKind::Unknown
);
assert_eq!(
address_kind_from_url("ftp://files.example.com/"),
AddressKind::Unknown
);
}
#[test]
fn address_kind_from_url_file_directory_classification_is_syntax_based() {
assert_eq!(
address_kind_from_url("file:///tmp/sample-dir/"),
AddressKind::Directory
);
assert_eq!(
address_kind_from_url("file:///tmp/sample-dir"),
AddressKind::File
);
}
#[test]
fn address_from_url_http() {
assert_eq!(
address_from_url("https://example.com"),
Address::Http("https://example.com".to_string())
);
assert_eq!(
address_from_url("http://example.com/path"),
Address::Http("http://example.com/path".to_string())
);
}
#[test]
fn address_from_url_file_and_directory() {
assert_eq!(
address_from_url("file:///home/user/file.txt"),
Address::File("file:///home/user/file.txt".to_string())
);
assert_eq!(
address_from_url("file:///tmp/mydir/"),
Address::Directory("file:///tmp/mydir/".to_string())
);
}
#[test]
fn address_from_url_data_and_custom() {
assert_eq!(
address_from_url("data:text/plain,hello"),
Address::Data("data:text/plain,hello".to_string())
);
assert_eq!(
address_from_url("gemini://gemini.circumlunar.space/"),
Address::Custom("gemini://gemini.circumlunar.space/".to_string())
);
}
#[test]
fn address_from_url_clip_stores_full_url() {
assert_eq!(
address_from_url("verso://clip/clip-abc-123"),
Address::Clip("verso://clip/clip-abc-123".to_string())
);
assert_eq!(
address_from_url("graphshell://clip/clip-xyz"),
Address::Clip("graphshell://clip/clip-xyz".to_string())
);
}
#[test]
fn address_as_url_str_roundtrips_for_all_variants() {
let cases = [
"https://example.com",
"file:///home/user/file.txt",
"file:///tmp/mydir/",
"data:text/plain,hello",
"gemini://example.com/",
"verso://clip/clip-abc",
"graphshell://clip/clip-xyz",
];
for url in cases {
let addr = address_from_url(url);
assert_eq!(
addr.as_url_str(),
url,
"as_url_str should return the original URL for {url}"
);
}
}
#[test]
fn address_address_kind_bridge_matches_legacy_inference() {
let cases = [
("https://example.com", AddressKind::Http),
("http://example.com", AddressKind::Http),
("file:///home/user/file.txt", AddressKind::File),
("file:///tmp/mydir/", AddressKind::Directory),
("data:text/plain,hello", AddressKind::Data),
("verso://clip/clip-123", AddressKind::GraphshellClip),
("graphshell://clip/clip-456", AddressKind::GraphshellClip),
("gemini://example.com/", AddressKind::Unknown),
];
for (url, expected_kind) in cases {
assert_eq!(
address_from_url(url).address_kind(),
expected_kind,
"address_kind() mismatch for {url}"
);
assert_eq!(
address_kind_from_url(url),
expected_kind,
"address_kind_from_url mismatch for {url}"
);
}
}
}