//! To do.
use crate::event::{Event, Kind, Name};
use crate::tokenizer::Tokenizer;
use crate::util::classify_character::{classify, Kind as CharacterKind};
use crate::util::slice::{Position, Slice};
use alloc::vec::Vec;
use core::str;
// To do: doc al functions.
pub fn resolve(tokenizer: &mut Tokenizer) {
tokenizer.map.consume(&mut tokenizer.events);
let mut index = 0;
let mut links = 0;
while index < tokenizer.events.len() {
let event = &tokenizer.events[index];
if event.kind == Kind::Enter {
if event.name == Name::Link {
links += 1;
}
} else {
if event.name == Name::Data && links == 0 {
let slice = Slice::from_position(
tokenizer.parse_state.bytes,
&Position::from_exit_event(&tokenizer.events, index),
);
let bytes = slice.bytes;
let mut byte_index = 0;
let mut replace = Vec::new();
let mut point = tokenizer.events[index - 1].point.clone();
let start_index = point.index;
let mut start = 0;
while byte_index < bytes.len() {
if matches!(bytes[byte_index], b'H' | b'h' | b'W' | b'w' | b'@') {
if let Some(autolink) = peek(bytes, byte_index) {
byte_index = autolink.1;
// If there is something between the last link
// (or the start) and this link.
if start != autolink.0 {
replace.push(Event {
kind: Kind::Enter,
name: Name::Data,
point: point.clone(),
link: None,
});
point = point.shift_to(
tokenizer.parse_state.bytes,
start_index + autolink.0,
);
replace.push(Event {
kind: Kind::Exit,
name: Name::Data,
point: point.clone(),
link: None,
});
}
// Add the link.
replace.push(Event {
kind: Kind::Enter,
name: autolink.2.clone(),
point: point.clone(),
link: None,
});
point = point
.shift_to(tokenizer.parse_state.bytes, start_index + autolink.1);
replace.push(Event {
kind: Kind::Exit,
name: autolink.2.clone(),
point: point.clone(),
link: None,
});
start = autolink.1;
}
}
byte_index += 1;
}
// If there was a link, and we have more bytes left.
if start != 0 && start < bytes.len() {
replace.push(Event {
kind: Kind::Enter,
name: Name::Data,
point: point.clone(),
link: None,
});
replace.push(Event {
kind: Kind::Exit,
name: Name::Data,
point: event.point.clone(),
link: None,
});
}
// If there were links.
if !replace.is_empty() {
tokenizer.map.add(index - 1, 2, replace);
}
}
if event.name == Name::Link {
links -= 1;
}
}
index += 1;
}
}
fn peek(bytes: &[u8], index: usize) -> Option<(usize, usize, Name)> {
// Protocol.
if let Some(protocol_end) = peek_protocol(bytes, index) {
if let Some(domain_end) = peek_domain(bytes, protocol_end, true) {
let end = truncate(bytes, protocol_end, domain_end);
// Cannot be empty.
if end != protocol_end {
return Some((index, end, Name::GfmAutolinkLiteralProtocol));
}
}
}
// Www.
if peek_www(bytes, index).is_some() {
// Note: we discard the `www.` we parsed, we now try to parse it as a domain.
let domain_end = peek_domain(bytes, index, false).unwrap_or(index);
let end = truncate(bytes, index, domain_end);
return Some((index, end, Name::GfmAutolinkLiteralWww));
}
// Email.
if bytes[index] == b'@' {
if let Some(start) = peek_atext(bytes, index) {
if let Some(end) = peek_email_domain(bytes, index + 1) {
let end = truncate(bytes, start, end);
return Some((start, end, Name::GfmAutolinkLiteralEmail));
}
}
}
None
}
/// Move past `http://`, `https://`, case-insensitive.
fn peek_protocol(bytes: &[u8], mut index: usize) -> Option<usize> {
// `http`
if index + 3 < bytes.len()
&& matches!(bytes[index], b'H' | b'h')
&& matches!(bytes[index + 1], b'T' | b't')
&& matches!(bytes[index + 2], b'T' | b't')
&& matches!(bytes[index + 3], b'P' | b'p')
{
index += 4;
// `s`, optional.
if index + 1 < bytes.len() && matches!(bytes[index], b'S' | b's') {
index += 1;
}
// `://`
if index + 3 < bytes.len()
&& bytes[index] == b':'
&& bytes[index + 1] == b'/'
&& bytes[index + 2] == b'/'
{
return Some(index + 3);
}
}
None
}
/// Move past `www.`, case-insensitive.
fn peek_www(bytes: &[u8], index: usize) -> Option<usize> {
// `www.`
if index + 3 < bytes.len()
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.
&& (index == 0 || matches!(bytes[index - 1], b'\t' | b'\n' | b'\r' | b' ' | b'(' | b'*' | b'_' | b'~'))
&& matches!(bytes[index], b'W' | b'w')
&& matches!(bytes[index + 1], b'W' | b'w')
&& matches!(bytes[index + 2], b'W' | b'w')
&& bytes[index + 3] == b'.'
{
Some(index + 4)
} else {
None
}
}
/// Move past `example.com`.
fn peek_domain(bytes: &[u8], start: usize, allow_short: bool) -> Option<usize> {
let mut dots = false;
let mut penultime = false;
let mut last = false;
// To do: expose this from slice?
// To do: do it ourselves? <https://github.com/commonmark/cmark/blob/8a023286198a7e408398e282f293e3b0baebb644/src/utf8.c#L150>, <https://doc.rust-lang.org/core/str/fn.next_code_point.html>, <https://www.reddit.com/r/rust/comments/4g2zu0/lazy_unicode_iterator_from_byte_iteratorslice/>, <http://bjoern.hoehrmann.de/utf-8/decoder/dfa/>.
let char_indices = str::from_utf8(&bytes[start..])
.unwrap()
.char_indices()
.collect::<Vec<_>>();
let mut index = 0;
while index < char_indices.len() {
match char_indices[index].1 {
'_' => last = true,
'.' => {
penultime = last;
last = false;
dots = true;
}
'-' => {}
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.
char if classify(char) == CharacterKind::Other => {}
_ => break,
}
index += 1;
}
// No underscores allowed in last two parts.
// A valid domain needs to have at least a dot.
if penultime || last || (!allow_short && !dots) {
None
} else {
// Now peek past `/path?search#hash` (anything except whitespace).
while index < char_indices.len() {
if classify(char_indices[index].1) == CharacterKind::Whitespace {
break;
}
index += 1;
}
Some(if index == char_indices.len() {
bytes.len()
} else {
start + char_indices[index].0
})
}
}
/// Move back past `contact`.
fn peek_atext(bytes: &[u8], end: usize) -> Option<usize> {
let mut index = end;
// Take simplified atext.
// See `email_atext` in `autolink.rs` for a similar algorithm.
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L301>.
while index > 0
&& matches!(bytes[index - 1], b'+' | b'-' | b'.' | b'0'..=b'9' | b'A'..=b'Z' | b'_' | b'a'..=b'z')
{
index -= 1;
}
// Do not allow a slash “inside” atext.
// The reference code is a bit weird, but that’s what it results in.
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.
// Other than slash, every preceding character is allowed.
if index == end || (index > 0 && bytes[index - 1] == b'/') {
None
} else {
Some(index)
}
}
/// Move past `example.com`.
fn peek_email_domain(bytes: &[u8], start: usize) -> Option<usize> {
let mut index = start;
let mut dot = false;
// Move past “domain”.
// The reference code is a bit overly complex as it handles the `@`, of which there may be just one.
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>
while index < bytes.len() {
match bytes[index] {
// Alphanumerical, `-`, and `_`.
b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'_' | b'a'..=b'z' => {}
// Dot followed by alphanumerical (not `-` or `_`).
b'.' if index + 1 < bytes.len()
&& matches!(bytes[index + 1], b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z') =>
{
dot = true;
}
_ => break,
}
index += 1;
}
// Domain must not be empty, must include a dot, and must end in alphabetical or `.`.
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.
if index > start && dot && matches!(bytes[index - 1], b'.' | b'A'..=b'Z' | b'a'..=b'z') {
Some(index)
} else {
None
}
}
/// Split trialing stuff from a URL.
fn truncate(bytes: &[u8], start: usize, mut end: usize) -> usize {
let mut index = start;
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L42>
while index < end {
if bytes[index] == b'<' {
end = index;
break;
}
index += 1;
}
let mut split = end;
// Move before trailing punctuation.
while split > start {
match bytes[split - 1] {
b'!' | b'"' | b'&' | b'\'' | b')' | b',' | b'.' | b':' | b'<' | b'>' | b'?' | b']'
| b'}' => {}
// Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L61>.
// Note: we can’t move across actual references, because those have been parsed already.
b';' => {
let mut new_split = split - 1;
// Move back past alphabeticals.
while new_split > start && matches!(bytes[new_split - 1], b'A'..=b'Z' | b'a'..=b'z')
{
new_split -= 1;
}
// Nonempty character reference:
if new_split > start && bytes[new_split - 1] == b'&' && new_split < split - 1 {
split = new_split - 1;
continue;
}
// Otherwise it’s just a `;`.
}
_ => break,
}
split -= 1;
}
// If there was trailing punctuation, try to balance parens.
if split != end {
let mut open = 0;
let mut close = 0;
let mut paren_index = start;
// Count parens in `url` (not in trail).
while paren_index < split {
match bytes[paren_index] {
b'(' => open += 1,
b')' => close += 1,
_ => {}
}
paren_index += 1;
}
let mut trail_index = split;
// If there are more opening than closing parens, try to balance them
// from the trail.
while open > close && trail_index < end {
if bytes[trail_index] == b')' {
split = trail_index;
close += 1;
}
trail_index += 1;
}
}
split
}
