use cpp_parser::SourceRange;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DocTarget {
pub range: SourceRange,
pub target: String,
}
impl DocTarget {
pub fn spelled_for_a_lookup(&self) -> &str {
self.target
.trim_end_matches("()")
.trim_end_matches('!')
.trim()
}
}
pub fn target_at(text: &str, offset: usize) -> Option<DocTarget> {
let whole = SourceRange::new(0, text.len());
let holds = |range: &SourceRange| range.start_offset <= offset && offset <= range.end_offset();
if let Some(link) = cpp_parser::doc_links(text, whole)
.into_iter()
.find(|link| holds(&link.range))
{
return Some(DocTarget {
range: link.range,
target: link.target,
});
}
cpp_parser::doc_references(text, whole)
.into_iter()
.find(|reference| holds(&reference.range))
.map(|reference| DocTarget {
range: reference.range,
target: reference.target,
})
}
pub fn targets(text: &str) -> Vec<DocTarget> {
let whole = SourceRange::new(0, text.len());
let mut found: Vec<DocTarget> = cpp_parser::doc_links(text, whole)
.into_iter()
.map(|link| DocTarget {
range: link.range,
target: link.target,
})
.chain(
cpp_parser::doc_references(text, whole)
.into_iter()
.map(|reference| DocTarget {
range: reference.range,
target: reference.target,
}),
)
.collect();
found.sort_by_key(|target| (target.range.start_offset, target.range.end_offset()));
found
}
pub fn is_a_documentation_comment(text: &str, offset: usize) -> bool {
let offset = offset.min(text.len());
let before = &text[..offset];
let line_start = before.rfind('\n').map_or(0, |at| at + 1);
let trimmed = text[line_start..].trim_start();
if trimmed.starts_with("///") || trimmed.starts_with("//!") || trimmed.starts_with("/**") {
return true;
}
match (before.rfind("/*"), before.rfind("*/")) {
(Some(opened), closed) => {
let still_open = closed.is_none_or(|closed| closed < opened);
still_open
&& (before[opened..].starts_with("/**") || before[opened..].starts_with("/*!"))
}
_ => false,
}
}
pub fn code_blocks(text: &str) -> Vec<SourceRange> {
let mut spans = Vec::new();
let mut at = 0usize;
while let Some(open) = text[at..]
.find("@code")
.map(|offset| at + offset)
.or_else(|| text[at..].find("\\code").map(|offset| at + offset))
{
let opens_at = open + "@code".len();
let start = text[opens_at..]
.find('\n')
.map_or(text.len(), |offset| opens_at + offset + 1);
let close = text[start..]
.find("@endcode")
.map(|offset| start + offset)
.or_else(|| text[start..].find("\\endcode").map(|offset| start + offset));
let end = close.unwrap_or(text.len());
let mut line_start = start;
for line in text[start..end].split_inclusive('\n') {
let indentation = line.len() - line.trim_start().len();
let body = line.trim_start();
let marker = if let Some(rest) = body
.strip_prefix("///")
.or_else(|| body.strip_prefix("//!"))
.or_else(|| body.strip_prefix("//"))
.or_else(|| body.strip_prefix('*'))
{
body.len() - rest.len()
} else {
0
};
let content = body[marker..].trim_end_matches(['\r', '\n']);
let content = content.strip_prefix(' ').unwrap_or(content);
if !content.trim().is_empty() {
spans.push(SourceRange::new(
line_start + indentation + marker,
content.len(),
));
}
line_start += line.len();
}
match close {
Some(end) => at = end + "@endcode".len(),
None => break,
}
}
spans
}
pub fn inside_a_code_block(text: &str, offset: usize) -> bool {
let offset = offset.min(text.len());
let before = &text[..offset];
let opened = before.rfind("@code").or_else(|| before.rfind("\\code"));
let closed = before
.rfind("@endcode")
.or_else(|| before.rfind("\\endcode"));
match (opened, closed) {
(Some(opened), Some(closed)) => opened > closed,
(Some(_), None) => true,
_ => false,
}
}