use crate::analysis::findings::Finding;
use crate::docs::{Check, Line, finding};
use crate::text::excerpt;
const URL_EXCERPT_MAX: usize = 60;
const SCHEMES: [&[char]; 2] = [
&['h', 't', 't', 'p', 's', ':', '/', '/'],
&['h', 't', 't', 'p', ':', '/', '/'],
];
pub fn check(
line: &Line<'_>,
chars: &[char],
scratch: &mut Vec<char>,
file_path: &str,
out: &mut Vec<Finding>,
) {
if line.in_fence {
return;
}
let blanked: &[char] = if line.text.contains(['`', '[', '<']) {
scratch.clear();
scratch.extend_from_slice(chars);
blank_inline_code(scratch);
blank_links(scratch);
blank_autolinks(scratch);
blank_raw_html(scratch);
blank_reference_definition(scratch);
scratch
} else {
chars
};
bare_url(line, blanked, file_path, out);
link_syntax(line, blanked, file_path, out);
}
fn blank_inline_code(chars: &mut [char]) {
let mut i = 0;
while i < chars.len() {
if chars[i] != '`' {
i += 1;
continue;
}
let open = backtick_run(chars, i);
let mut j = i + open;
let mut close = None;
while j < chars.len() {
if chars[j] == '`' {
let run = backtick_run(chars, j);
if run == open {
close = Some(j + run);
break;
}
j += run;
} else {
j += 1;
}
}
match close {
Some(end) => {
chars[i..end].fill(' ');
i = end;
}
None => i += open,
}
}
}
fn backtick_run(chars: &[char], start: usize) -> usize {
chars[start..].iter().take_while(|c| **c == '`').count()
}
fn blank_links(chars: &mut [char]) {
let mut i = 0;
while i < chars.len() {
if chars[i] == '['
&& let Some(end) = match_link(chars, i)
{
chars[i..=end].fill(' ');
i = end;
}
i += 1;
}
}
fn match_link(chars: &[char], start: usize) -> Option<usize> {
debug_assert_eq!(chars[start], '[');
let mut j = start + 1;
loop {
match chars.get(j)? {
'[' => {
let close = (j..chars.len()).find(|k| chars[*k] == ']')?;
j = close + 1;
}
']' => {
if chars.get(j + 1) != Some(&'(') {
return None;
}
return (j + 2..chars.len()).find(|m| chars[*m] == ')');
}
_ => j += 1,
}
}
}
fn blank_autolinks(chars: &mut [char]) {
let mut i = 0;
while i < chars.len() {
if chars[i] == '<'
&& let Some(end) = match_autolink(chars, i)
{
chars[i..=end].fill(' ');
i = end;
}
i += 1;
}
}
fn match_autolink(chars: &[char], start: usize) -> Option<usize> {
debug_assert_eq!(chars[start], '<');
if !SCHEMES
.iter()
.any(|scheme| chars[start + 1..].starts_with(scheme))
{
return None;
}
(start + 1..chars.len())
.find(|i| chars[*i].is_ascii_control() || matches!(chars[*i], ' ' | '<' | '>'))
.filter(|end| chars[*end] == '>')
}
fn blank_raw_html(chars: &mut [char]) {
let mut i = 0;
while i < chars.len() {
if chars[i] == '<'
&& let Some(end) = match_comment(chars, i).or_else(|| match_tag(chars, i))
{
chars[i..=end].fill(' ');
i = end;
}
i += 1;
}
}
fn match_comment(chars: &[char], start: usize) -> Option<usize> {
const OPEN: [char; 4] = ['<', '!', '-', '-'];
const CLOSE: [char; 3] = ['-', '-', '>'];
if !chars[start..].starts_with(&OPEN) {
return None;
}
(start + 2..chars.len())
.find(|i| chars[*i..].starts_with(&CLOSE))
.map(|i| i + CLOSE.len() - 1)
}
fn match_tag(chars: &[char], start: usize) -> Option<usize> {
debug_assert_eq!(chars[start], '<');
let closing = chars.get(start + 1) == Some(&'/');
let name = start + 1 + usize::from(closing);
if !chars.get(name)?.is_ascii_alphabetic() {
return None;
}
let mut i = skip_while(chars, name, |c| c.is_ascii_alphanumeric() || c == '-');
if closing {
i = skip_while(chars, i, is_tag_space);
return (chars.get(i) == Some(&'>')).then_some(i);
}
loop {
let attributes = skip_while(chars, i, is_tag_space);
let separated = attributes > i;
match *chars.get(attributes)? {
'>' => return Some(attributes),
'/' => {
let close = attributes + 1;
return (chars.get(close) == Some(&'>')).then_some(close);
}
c if separated && (c.is_ascii_alphabetic() || matches!(c, '_' | ':')) => {
i = attribute_end(chars, attributes)?;
}
_ => return None,
}
}
}
fn attribute_end(chars: &[char], start: usize) -> Option<usize> {
let name_end = skip_while(chars, start, |c| {
c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | ':' | '-')
});
let equals = skip_while(chars, name_end, is_tag_space);
if chars.get(equals) != Some(&'=') {
return Some(name_end);
}
let value = skip_while(chars, equals + 1, is_tag_space);
match *chars.get(value)? {
quote @ ('"' | '\'') => (value + 1..chars.len())
.find(|i| chars[*i] == quote)
.map(|close| close + 1),
_ => {
let end = skip_while(chars, value, |c| {
!is_tag_space(c) && !matches!(c, '"' | '\'' | '=' | '<' | '>' | '`')
});
(end > value).then_some(end)
}
}
}
fn is_tag_space(c: char) -> bool {
matches!(c, ' ' | '\t')
}
fn skip_while(chars: &[char], from: usize, keep: impl Fn(char) -> bool) -> usize {
(from..chars.len())
.find(|i| !keep(chars[*i]))
.unwrap_or(chars.len())
}
fn blank_reference_definition(chars: &mut [char]) {
let Some(open) = chars.iter().position(|c| !c.is_whitespace()) else {
return;
};
if chars[open] != '[' {
return;
}
let Some(close) = (open + 1..chars.len()).find(|i| matches!(chars[*i], '[' | ']')) else {
return;
};
if chars[close] != ']' || chars.get(close + 1) != Some(&':') {
return;
}
let Some(destination) = (close + 2..chars.len()).find(|i| !chars[*i].is_whitespace()) else {
return;
};
chars[destination..].fill(' ');
}
fn bare_url(line: &Line<'_>, blanked: &[char], file_path: &str, out: &mut Vec<Finding>) {
let Some(start) = find_url(blanked) else {
return;
};
let end = (start..blanked.len())
.find(|i| blanked[*i].is_whitespace())
.unwrap_or(blanked.len());
let url: String = blanked[start..end].iter().collect();
out.push(finding(
Check::BareUrl,
file_path,
line.number,
start as u32 + 1,
format!("bare URL: {}", excerpt(&url, URL_EXCERPT_MAX)),
));
}
fn find_url(chars: &[char]) -> Option<usize> {
(0..chars.len()).find(|start| {
chars[*start] == 'h'
&& SCHEMES.iter().any(|scheme| {
chars[*start..].starts_with(scheme)
&& chars
.get(start + scheme.len())
.is_some_and(|c| !c.is_whitespace())
})
})
}
fn link_syntax(line: &Line<'_>, blanked: &[char], file_path: &str, out: &mut Vec<Finding>) {
let count = |target: char| blanked.iter().filter(|c| **c == target).count();
let (open_square, close_square) = (count('['), count(']'));
let (open_round, close_round) = (count('('), count(')'));
let detail = if open_square != close_square {
format!("{open_square} `[` against {close_square} `]`")
} else if blanked.windows(2).any(|w| w == [']', '(']) && open_round != close_round {
format!("{open_round} `(` against {close_round} `)`")
} else {
return;
};
out.push(finding(
Check::LinkSyntaxInvalid,
file_path,
line.number,
1,
format!("unbalanced link syntax: {detail}"),
));
}