use url::Url;
use crate::domain::{AllowedOrigin, CrateName, VersionArg};
use crate::error::{AppError, AppResult, ErrorKind};
use crate::item_kind::{ItemKind, rustc_crate_name};
use super::hits::{leaf_eq_ignore_ascii, unique_best_score_hit};
use super::types::SearchInCrateHit;
fn default_docs_origin(crate_name: &CrateName) -> AllowedOrigin {
if crate_name.is_stdlib() {
AllowedOrigin::stdlib_docs_default()
} else {
AllowedOrigin::docs_rs_default()
}
}
pub fn readme_url(crate_name: &CrateName, version: &VersionArg) -> AppResult<Url> {
readme_url_on_origin(&default_docs_origin(crate_name), crate_name, version)
}
pub fn readme_url_on_origin(
origin: &AllowedOrigin,
crate_name: &CrateName,
version: &VersionArg,
) -> AppResult<Url> {
let origin = origin.as_str().trim_end_matches('/');
let s = if crate_name.is_stdlib() {
let channel = version.stdlib_channel();
format!("{origin}/{channel}/{crate_name}/index.html")
} else {
let rustc = rustc_crate_name(crate_name.as_str());
format!("{origin}/{crate_name}/{version}/{rustc}/index.html")
};
Url::parse(&s).map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid readme URL", e))
}
pub fn get_item_url(
crate_name: &CrateName,
version: &VersionArg,
kind: ItemKind,
segments: &[String],
) -> AppResult<Url> {
get_item_url_on_origin(
&default_docs_origin(crate_name),
crate_name,
version,
kind,
segments,
)
}
pub fn is_method_path(kind: ItemKind, segs: &[String]) -> bool {
if segs.len() < 2 {
return false;
}
if kind != ItemKind::Fn {
return false;
}
let parent = segs[segs.len() - 2].as_str();
let method = segs[segs.len() - 1].as_str();
let parent_type = parent
.chars()
.next()
.is_some_and(|c| c.is_ascii_uppercase());
let method_fn = method
.chars()
.next()
.is_some_and(|c| c.is_ascii_lowercase() || c == '_');
parent_type && method_fn
}
pub fn strip_crate_prefix_segments(
crate_name: &CrateName,
kind: ItemKind,
segments: &[String],
) -> Vec<String> {
let rustc_root = rustc_crate_name(crate_name.as_str());
let mut s = segments.to_vec();
if let Some(first) = s.first() {
let f = first.as_str();
let is_crate_prefix = f == crate_name.as_str() || f == rustc_root.as_str();
if is_crate_prefix && (s.len() >= 2 || kind == ItemKind::Module) {
s.remove(0);
}
}
s
}
pub const METHOD_PARENT_KIND_NAMES: &[&str] = &["struct", "enum", "trait", "type", "union"];
pub fn pick_unique_type_path(leaf: &str, hits: &[SearchInCrateHit]) -> Option<String> {
let needle = leaf.trim().to_ascii_lowercase();
if needle.is_empty() {
return None;
}
let exact: Vec<&SearchInCrateHit> = hits
.iter()
.filter(|h| {
METHOD_PARENT_KIND_NAMES.contains(&h.kind.as_str())
&& leaf_eq_ignore_ascii(&h.name, &needle)
})
.collect();
if exact.len() == 1 {
return Some(exact[0].name.clone());
}
if exact.is_empty() {
return None;
}
let structs: Vec<_> = exact.iter().filter(|h| h.kind == "struct").copied().collect();
if structs.len() == 1 {
return Some(structs[0].name.clone());
}
unique_best_score_hit(exact.into_iter()).map(|h| h.name.clone())
}
pub fn method_segments_from_parent(parent_path: &str, method_leaf: &str) -> Vec<String> {
let mut segs: Vec<String> = parent_path
.split("::")
.filter(|s| !s.is_empty())
.map(str::to_string)
.collect();
segs.push(method_leaf.to_string());
segs
}
pub(super) const METHOD_PARENT_KINDS: &[ItemKind] = &[
ItemKind::Struct,
ItemKind::Enum,
ItemKind::Trait,
ItemKind::Type,
ItemKind::Union,
];
pub fn get_item_url_on_origin(
origin: &AllowedOrigin,
crate_name: &CrateName,
version: &VersionArg,
kind: ItemKind,
segments: &[String],
) -> AppResult<Url> {
get_item_url_on_origin_with_parent_kind(origin, crate_name, version, kind, segments, None)
}
pub fn get_item_url_on_origin_with_parent_kind(
origin: &AllowedOrigin,
crate_name: &CrateName,
version: &VersionArg,
kind: ItemKind,
segments: &[String],
parent_kind_override: Option<ItemKind>,
) -> AppResult<Url> {
let origin = origin.as_str().trim_end_matches('/');
let rustc_root = rustc_crate_name(crate_name.as_str());
let segs: Vec<String> = {
let mut s = segments.to_vec();
if let Some(first) = s.first() {
let f = first.as_str();
let is_crate_prefix = f == crate_name.as_str() || f == rustc_root.as_str();
if is_crate_prefix && (s.len() >= 2 || kind == ItemKind::Module) {
s.remove(0);
}
}
s
};
if is_method_path(kind, &segs) {
let (parent_name, method_name) = match segs.as_slice() {
[.., parent, method] => (parent.clone(), method.clone()),
_ => {
return Err(AppError::new(
ErrorKind::Internal,
"method path invariant broken: expected at least 2 segments",
));
}
};
let parent_kind = parent_kind_override.unwrap_or(ItemKind::Struct);
let mod_parts: Vec<String> = if segs.len() == 2 {
if crate_name.is_stdlib() {
Vec::new()
} else {
vec![rustc_root.clone()]
}
} else {
let mut m = if crate_name.is_stdlib() {
Vec::new()
} else {
vec![rustc_root.clone()]
};
for p in &segs[..segs.len() - 2] {
m.push(rustc_crate_name(p));
}
m
};
let url_str = if crate_name.is_stdlib() {
let channel = version.stdlib_channel();
if mod_parts.is_empty() {
format!(
"{origin}/{channel}/{crate_name}/{}.{}.html#method.{method_name}",
parent_kind.file_prefix(),
parent_name
)
} else {
format!(
"{origin}/{channel}/{crate_name}/{}/{}.{}.html#method.{method_name}",
mod_parts.join("/"),
parent_kind.file_prefix(),
parent_name
)
}
} else if mod_parts.is_empty() {
format!(
"{origin}/{crate_name}/{version}/{}/{}.{}.html#method.{method_name}",
rustc_root,
parent_kind.file_prefix(),
parent_name
)
} else {
format!(
"{origin}/{crate_name}/{version}/{}/{}.{}.html#method.{method_name}",
mod_parts.join("/"),
parent_kind.file_prefix(),
parent_name
)
};
return Url::parse(&url_str)
.map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid get-item URL", e));
}
let url_str = if crate_name.is_stdlib() {
let channel = version.stdlib_channel();
if kind == ItemKind::Module {
let mut parts: Vec<String> = Vec::new();
for p in &segs {
parts.push(rustc_crate_name(p));
}
if parts.is_empty() {
format!("{origin}/{channel}/{crate_name}/index.html")
} else {
format!(
"{origin}/{channel}/{crate_name}/{}/index.html",
parts.join("/")
)
}
} else {
if segs.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"item path missing item name",
));
}
let item_name = segs.last().ok_or_else(|| {
AppError::new(ErrorKind::InvalidInput, "item path missing item name")
})?;
let mod_parts: Vec<String> = segs[..segs.len().saturating_sub(1)]
.iter()
.map(|p| rustc_crate_name(p))
.collect();
if mod_parts.is_empty() {
format!(
"{origin}/{channel}/{crate_name}/{}.{}.html",
kind.file_prefix(),
item_name
)
} else {
format!(
"{origin}/{channel}/{crate_name}/{}/{}.{}.html",
mod_parts.join("/"),
kind.file_prefix(),
item_name
)
}
}
} else if kind == ItemKind::Module {
let mut parts: Vec<String> = vec![rustc_root];
for p in &segs {
parts.push(rustc_crate_name(p));
}
format!(
"{origin}/{crate_name}/{version}/{}/index.html",
parts.join("/")
)
} else {
if segs.is_empty() {
return Err(AppError::new(
ErrorKind::InvalidInput,
"item path missing item name",
));
}
let item_name = segs
.last()
.ok_or_else(|| AppError::new(ErrorKind::InvalidInput, "item path missing item name"))?;
let mod_parts: Vec<String> = if segs.len() == 1 {
vec![rustc_root]
} else {
let mut m = vec![rustc_root];
for p in &segs[..segs.len() - 1] {
m.push(rustc_crate_name(p));
}
m
};
format!(
"{origin}/{crate_name}/{version}/{}/{}.{}.html",
mod_parts.join("/"),
kind.file_prefix(),
item_name
)
};
Url::parse(&url_str)
.map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid get-item URL", e))
}
pub fn all_html_url(crate_name: &CrateName, version: &VersionArg) -> AppResult<Url> {
all_html_url_on_origin(&default_docs_origin(crate_name), crate_name, version)
}
pub fn all_html_url_on_origin(
origin: &AllowedOrigin,
crate_name: &CrateName,
version: &VersionArg,
) -> AppResult<Url> {
let origin = origin.as_str().trim_end_matches('/');
let s = if crate_name.is_stdlib() {
let channel = version.stdlib_channel();
format!("{origin}/{channel}/{crate_name}/all.html")
} else {
let rustc = rustc_crate_name(crate_name.as_str());
format!("{origin}/{crate_name}/{version}/{rustc}/all.html")
};
Url::parse(&s)
.map_err(|e| AppError::with_source(ErrorKind::Internal, "invalid all.html URL", e))
}