use url::Url;
use crate::domain::{AllowedOrigin, CrateName, VersionArg};
use crate::error::{AppError, AppResult, ErrorDetail, InternalOp};
use crate::item_kind::{ItemKind, rustc_crate_name};
use super::assoc::{AssocAnchorKind, associated_item_path, member_only_family};
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::of_with_source(
ErrorDetail::Internal {
op: InternalOp::UrlBuild,
},
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 {
associated_item_path(kind, segs) == Some(AssocAnchorKind::Method)
}
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 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| {
AssocAnchorKind::Method
.parent_kind_probe()
.iter()
.any(|k| k.as_str() == 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 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 = strip_crate_prefix_segments(crate_name, kind, segments);
if let Some(assoc) = associated_item_path(kind, &segs) {
let (parent_name, member_name) = match segs.as_slice() {
[.., parent, member] => (parent.clone(), member.clone()),
_ => {
return Err(AppError::of(ErrorDetail::Internal {
op: InternalOp::AssocPathTooShort,
}));
}
};
let anchor = format!("{}{member_name}", assoc.primary_prefix());
let parent_kind = parent_kind_override.unwrap_or(assoc.parent_kind_probe()[0]);
let parent_prefix = parent_kind.file_prefix().ok_or_else(|| {
AppError::of(ErrorDetail::Internal {
op: InternalOp::AssocParentOwnsNoPage,
})
})?;
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}/{parent_prefix}.{parent_name}.html#{anchor}"
)
} else {
format!(
"{origin}/{channel}/{crate_name}/{}/{}.{}.html#{anchor}",
mod_parts.join("/"),
parent_prefix,
parent_name
)
}
} else if mod_parts.is_empty() {
format!(
"{origin}/{crate_name}/{version}/{rustc_root}/{parent_prefix}.{parent_name}.html#{anchor}"
)
} else {
format!(
"{origin}/{crate_name}/{version}/{}/{}.{}.html#{anchor}",
mod_parts.join("/"),
parent_prefix,
parent_name
)
};
return Url::parse(&url_str).map_err(|e| {
AppError::of_with_source(
ErrorDetail::Internal {
op: InternalOp::UrlBuild,
},
e,
)
});
}
if let Some(family) = member_only_family(kind) {
return Err(AppError::of(ErrorDetail::MemberKindNeedsParent {
kind: kind.as_str(),
member: segs.last().map_or("member", String::as_str).to_string(),
parent_kinds: family
.parent_kind_probe_names()
.collect::<Vec<_>>()
.join(", "),
}));
}
let file_prefix = kind.file_prefix().unwrap_or(kind.as_str());
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::of(ErrorDetail::ItemPathMissingItemName));
}
let item_name = segs
.last()
.ok_or_else(|| AppError::of(ErrorDetail::ItemPathMissingItemName))?;
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}/{file_prefix}.{item_name}.html")
} else {
format!(
"{origin}/{channel}/{crate_name}/{}/{}.{}.html",
mod_parts.join("/"),
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::of(ErrorDetail::ItemPathMissingItemName));
}
let item_name = segs
.last()
.ok_or_else(|| AppError::of(ErrorDetail::ItemPathMissingItemName))?;
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("/"),
file_prefix,
item_name
)
};
Url::parse(&url_str).map_err(|e| {
AppError::of_with_source(
ErrorDetail::Internal {
op: InternalOp::UrlBuild,
},
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::of_with_source(
ErrorDetail::Internal {
op: InternalOp::UrlBuild,
},
e,
)
})
}