use std::sync::LazyLock;
use scraper::{Html, Selector};
use crate::docs_rs::assoc::{AssocAnchorKind, METHOD_ANCHOR_PREFIXES, strip_assoc_anchor_prefix};
use crate::error::{AppError, AppResult, ErrorDetail};
use super::sanitize::html_to_markdown;
static SEL_RUSTDOC_DOCBLOCK: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse(".rustdoc .docblock")
.expect("hardcoded scraper selector '.rustdoc .docblock' is valid by construction")
});
static SEL_MAIN_DOCBLOCK: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse("#main-content .docblock")
.expect("hardcoded scraper selector '#main-content .docblock' is valid by construction")
});
static SEL_DOCBLOCK: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse(".docblock")
.expect("hardcoded scraper selector '.docblock' is valid by construction")
});
static SEL_RUSTDOC_MAIN_ITEM_DECL: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse(".rustdoc-main .item-decl")
.expect("hardcoded scraper selector '.rustdoc-main .item-decl' is valid by construction")
});
static SEL_ITEM_DECL: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse(".item-decl")
.expect("hardcoded scraper selector '.item-decl' is valid by construction")
});
static SEL_MAIN_CONTENT: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse("#main-content")
.expect("hardcoded scraper selector '#main-content' is valid by construction")
});
static SEL_WITH_ID: LazyLock<Selector> = LazyLock::new(|| {
Selector::parse("[id]").expect("hardcoded scraper selector '[id]' is valid by construction")
});
fn first_inner_html(document: &Html, selectors: &[&Selector]) -> Option<String> {
for sel in selectors {
if let Some(n) = document.select(sel).next() {
let inner = n.inner_html();
if !inner.trim().is_empty() {
return Some(inner);
}
}
}
None
}
pub fn extract_readme_markdown_from_document(document: &Html) -> AppResult<(String, bool)> {
let content = first_inner_html(
document,
&[
&SEL_RUSTDOC_DOCBLOCK,
&SEL_MAIN_DOCBLOCK,
&SEL_DOCBLOCK,
&SEL_RUSTDOC_MAIN_ITEM_DECL,
&SEL_ITEM_DECL,
],
);
match content {
Some(h) => Ok((html_to_markdown(&h)?, false)),
None => Ok((String::new(), true)),
}
}
pub fn extract_readme_markdown_from_html(html: &str) -> AppResult<(String, bool)> {
extract_readme_markdown_from_document(&Html::parse_document(html))
}
pub fn extract_item_markdown_from_document(document: &Html) -> AppResult<(String, bool)> {
let content = first_inner_html(
document,
&[&SEL_MAIN_CONTENT, &SEL_ITEM_DECL, &SEL_DOCBLOCK],
)
.unwrap_or_default();
let empty = content.trim().is_empty();
if empty {
Ok((String::new(), true))
} else {
Ok((html_to_markdown(&content)?, false))
}
}
pub fn extract_item_markdown_from_html(html: &str) -> AppResult<(String, bool)> {
extract_item_markdown_from_document(&Html::parse_document(html))
}
pub fn extract_method_markdown_from_html(
html: &str,
method_name: &str,
) -> AppResult<(String, bool)> {
let found = extract_method_markdown_scoped(html, method_name)?;
Ok((found.markdown, found.empty))
}
#[derive(Debug, Clone)]
pub struct MethodExtract {
pub markdown: String,
pub empty: bool,
pub scope: &'static str,
pub anchor_id: String,
}
pub fn extract_method_markdown_scoped(html: &str, method_name: &str) -> AppResult<MethodExtract> {
extract_assoc_markdown_scoped_from_document(
&Html::parse_document(html),
METHOD_ANCHOR_PREFIXES,
method_name,
)
}
pub fn extract_assoc_markdown_scoped_from_document(
document: &Html,
prefixes: &[&str],
member_name: &str,
) -> AppResult<MethodExtract> {
let candidates: Vec<String> = prefixes
.iter()
.map(|prefix| format!("{prefix}{member_name}"))
.collect();
let mut best: Option<(usize, scraper::ElementRef<'_>)> = None;
for el in document.select(&SEL_WITH_ID) {
let Some(id) = el.value().attr("id") else {
continue;
};
let Some(rank) = candidates.iter().position(|c| c == id) else {
continue;
};
if best.as_ref().is_none_or(|(seen, _)| rank < *seen) {
best = Some((rank, el));
if rank == 0 {
break;
}
}
}
let Some((rank, el)) = best else {
return Err(AppError::of(ErrorDetail::AssocAnchorMissing {
anchors: candidates.join(", "),
}));
};
let anchor_id = candidates[rank].clone();
let frag_html = method_container_html(el);
let markdown = html_to_markdown(&frag_html)?;
if markdown.trim().is_empty() {
return Err(AppError::of(ErrorDetail::AssocAnchorEmpty {
anchor_id: anchor_id.to_string(),
}));
}
Ok(MethodExtract {
markdown,
empty: false,
scope: "method",
anchor_id,
})
}
pub fn strip_method_anchor_prefix(id: &str) -> Option<&str> {
strip_assoc_anchor_prefix(id, METHOD_ANCHOR_PREFIXES)
}
pub fn list_method_anchor_names(document: &Html) -> Vec<String> {
list_assoc_anchor_names(document, METHOD_ANCHOR_PREFIXES)
}
pub fn list_assoc_anchor_names(document: &Html, prefixes: &[&str]) -> Vec<String> {
let mut out = Vec::with_capacity(32);
let mut seen = std::collections::HashSet::with_capacity(32);
for el in document.select(&SEL_WITH_ID) {
if let Some(name) = el
.value()
.attr("id")
.and_then(|id| strip_assoc_anchor_prefix(id, prefixes))
{
let canonical = name.split('-').next().unwrap_or(name);
if !canonical.is_empty() && seen.insert(canonical.to_string()) {
out.push(canonical.to_string());
}
}
}
out
}
pub fn list_method_anchor_names_from_html(html: &str) -> Vec<String> {
list_method_anchor_names(&Html::parse_document(html))
}
pub fn list_assoc_anchor_names_from_html(html: &str, family: AssocAnchorKind) -> Vec<String> {
list_assoc_anchor_names(&Html::parse_document(html), family.anchor_prefixes())
}
fn method_container_html(anchor: scraper::ElementRef<'_>) -> String {
let mut node = anchor.parent();
while let Some(n) = node {
if let Some(el) = scraper::ElementRef::wrap(n) {
if el.value().name() == "details" {
return el.html();
}
node = el.parent();
} else {
break;
}
}
anchor.html()
}