#![deny(missing_docs)]
#![deny(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::todo,
clippy::unimplemented
)]
mod emoji;
mod emoji_data;
mod github;
mod prose;
mod toc;
mod typography;
pub use emoji::EmojiShortcodesPass;
pub use github::{GitHubReferencesPass, InvalidGitHubRepository};
pub use toc::{TableOfContentsError, build_table_of_contents};
pub use typography::{
TypographyLanguage, TypographyOptions, TypographyPass, UnsupportedTypographyLanguage,
};
use std::borrow::Cow;
use std::error::Error;
use std::fmt;
use std::ops::Range;
use ferromark::ast::{Document, Link, Node, Span, Text};
use ferromark::{Allocator, AutolinkMatcher, HtmlRendererOptions};
pub type BoxError = Box<dyn Error + Send + Sync + 'static>;
pub trait TransformPass: Send {
fn name(&self) -> &'static str;
fn apply<'arena>(
&mut self,
document: &mut Document<'arena>,
context: &TransformContext<'arena>,
) -> Result<(), BoxError>;
}
#[derive(Default)]
pub struct TransformPipeline {
passes: Vec<Box<dyn TransformPass>>,
}
impl TransformPipeline {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn add<P: TransformPass + 'static>(&mut self, pass: P) {
self.passes.push(Box::new(pass));
}
#[must_use]
pub fn len(&self) -> usize {
self.passes.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.passes.is_empty()
}
pub fn run<'arena>(
&mut self,
document: &mut Document<'arena>,
context: &TransformContext<'arena>,
) -> Result<(), TransformError> {
for (pass_index, pass) in self.passes.iter_mut().enumerate() {
let pass_name = pass.name();
if let Err(source) = pass.apply(document, context) {
return Err(TransformError {
pass_index,
pass_name,
source,
});
}
}
Ok(())
}
}
pub struct TransformContext<'arena> {
allocator: &'arena Allocator,
source: &'arena str,
autolink_matcher: Option<AutolinkMatcher>,
}
impl<'arena> TransformContext<'arena> {
#[must_use]
pub fn new(
allocator: &'arena Allocator,
source: &'arena str,
renderer_options: &HtmlRendererOptions,
) -> Self {
Self {
allocator,
source,
autolink_matcher: renderer_options.autolink_matcher(),
}
}
#[must_use]
pub const fn source(&self) -> &'arena str {
self.source
}
#[must_use]
pub fn alloc_str(&self, value: &str) -> &'arena str {
let allocator: &'arena Allocator = self.allocator;
allocator.alloc_str(value)
}
#[must_use]
pub fn replacement_text(&self, value: &str, span: Span) -> Text<'arena> {
Text {
value: self.alloc_str(value),
span,
}
}
#[must_use]
pub fn generated_text(&self, value: &str) -> Text<'arena> {
self.replacement_text(value, Span::empty())
}
pub fn replace_text_value(&self, text: &mut Text<'arena>, value: &str) {
text.value = self.alloc_str(value);
}
pub fn replace_text_range(
&self,
nodes: &mut ferromark::allocator::Vec<'arena, Node<'arena>>,
node_range: Range<usize>,
byte_range: Range<usize>,
replacement: &str,
) -> Result<Span, TextReplacementError> {
Self::replace_text_range_with_node(nodes, node_range, byte_range, |span| {
(!replacement.is_empty()).then(|| Node::Text(self.replacement_text(replacement, span)))
})
}
pub(crate) fn replace_text_range_with_node(
nodes: &mut ferromark::allocator::Vec<'arena, Node<'arena>>,
node_range: Range<usize>,
byte_range: Range<usize>,
replacement: impl FnOnce(Span) -> Option<Node<'arena>>,
) -> Result<Span, TextReplacementError> {
validate_node_range(nodes, &node_range)?;
validate_text_byte_range(nodes, &node_range, &byte_range)?;
let replacement_span = span_for_byte_range(nodes, &node_range, &byte_range);
let replacement = replacement(replacement_span);
if byte_range.is_empty() {
if let Some(node) = replacement {
insert_node_at_text_offset(nodes, &node_range, byte_range.start, node);
}
return Ok(Span::empty());
}
let (first, last, first_offset, last_offset) =
overlapping_text_nodes(nodes, &node_range, &byte_range)?;
let (first_value, first_span) = match &nodes[first] {
Node::Text(text) => (text.value, text.span),
_ => return Err(TextReplacementError::NonTextNode { index: first }),
};
let (last_value, last_span) = match &nodes[last] {
Node::Text(text) => (text.value, text.span),
_ => return Err(TextReplacementError::NonTextNode { index: last }),
};
let mut replacements = std::vec::Vec::with_capacity(last - first + 3);
let prefix = &first_value[..first_offset];
if !prefix.is_empty() {
replacements.push(Node::Text(Text {
value: prefix,
span: first_span,
}));
}
if let Some(replacement) = replacement {
replacements.push(replacement);
}
if first < last {
for node in &nodes[first + 1..last] {
if let Node::Text(text) = node
&& text.value.is_empty()
{
replacements.push(Node::Text(Text {
value: text.value,
span: text.span,
}));
}
}
}
let suffix = &last_value[last_offset..];
if !suffix.is_empty() {
replacements.push(Node::Text(Text {
value: suffix,
span: last_span,
}));
}
drop(nodes.splice(first..last + 1, replacements));
Ok(replacement_span)
}
pub(crate) fn text_link_node(&self, label: &str, url: &str, span: Span) -> Node<'arena> {
let mut children = self.allocator.new_vec();
children.push(Node::Text(self.replacement_text(label, span)));
Node::Link(self.allocator.boxed(Link {
url: self.alloc_str(url),
title: None,
attributes: None,
children,
span,
}))
}
}
pub struct TextRun<'nodes, 'arena> {
nodes: &'nodes [Node<'arena>],
node_range: Range<usize>,
}
impl<'nodes, 'arena> TextRun<'nodes, 'arena> {
#[must_use]
pub fn node_range(&self) -> Range<usize> {
self.node_range.clone()
}
pub fn segments(&self) -> impl Iterator<Item = TextSegment<'arena>> + '_ {
self.nodes.iter().filter_map(|node| {
if let Node::Text(text) = node {
Some(TextSegment {
value: text.value,
span: text.span,
})
} else {
None
}
})
}
#[must_use]
pub fn protected_url_ranges(&self, context: &TransformContext<'_>) -> Vec<Range<usize>> {
let mut ranges = Vec::new();
let Some(matcher) = &context.autolink_matcher else {
return ranges;
};
let mut offset = 0;
for segment in self.segments() {
ranges.extend(
matcher
.find_ranges(segment.value)
.into_iter()
.map(|range| range.start + offset..range.end + offset),
);
offset += segment.value.len();
}
ranges
}
#[must_use]
pub fn value(&self) -> Cow<'arena, str> {
if let [Node::Text(text)] = self.nodes {
return Cow::Borrowed(text.value);
}
let capacity = self.segments().map(|segment| segment.value.len()).sum();
let mut value = String::with_capacity(capacity);
for segment in self.segments() {
value.push_str(segment.value);
}
Cow::Owned(value)
}
#[must_use]
pub fn source_span(&self) -> Span {
span_for_byte_range(self.nodes, &(0..self.nodes.len()), &self.value_range())
}
pub fn span_for_bytes(&self, range: Range<usize>) -> Result<Span, TextReplacementError> {
let value = self.value();
validate_byte_range(&value, &range)?;
Ok(span_for_byte_range(
self.nodes,
&(0..self.nodes.len()),
&range,
))
}
fn value_range(&self) -> Range<usize> {
0..self.segments().map(|segment| segment.value.len()).sum()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TextSegment<'arena> {
pub value: &'arena str,
pub span: Span,
}
pub struct TextRuns<'nodes, 'arena> {
nodes: &'nodes [Node<'arena>],
cursor: usize,
}
impl<'nodes, 'arena> Iterator for TextRuns<'nodes, 'arena> {
type Item = TextRun<'nodes, 'arena>;
fn next(&mut self) -> Option<Self::Item> {
while self.cursor < self.nodes.len() && !matches!(self.nodes[self.cursor], Node::Text(_)) {
self.cursor += 1;
}
if self.cursor == self.nodes.len() {
return None;
}
let start = self.cursor;
while self.cursor < self.nodes.len() && matches!(self.nodes[self.cursor], Node::Text(_)) {
self.cursor += 1;
}
Some(TextRun {
nodes: &self.nodes[start..self.cursor],
node_range: start..self.cursor,
})
}
}
#[must_use]
pub fn text_runs<'nodes, 'arena>(nodes: &'nodes [Node<'arena>]) -> TextRuns<'nodes, 'arena> {
TextRuns { nodes, cursor: 0 }
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum TextReplacementError {
InvalidNodeRange {
start: usize,
end: usize,
node_count: usize,
},
NonTextNode {
index: usize,
},
ReversedByteRange {
start: usize,
end: usize,
},
ByteRangeOutOfBounds {
end: usize,
text_len: usize,
},
NotCharBoundary {
offset: usize,
},
}
impl fmt::Display for TextReplacementError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidNodeRange {
start,
end,
node_count,
} => write!(
formatter,
"text node range {start}..{end} is invalid for {node_count} nodes"
),
Self::NonTextNode { index } => {
write!(formatter, "node {index} in the selected range is not text")
}
Self::ReversedByteRange { start, end } => {
write!(formatter, "text byte range {start}..{end} is reversed")
}
Self::ByteRangeOutOfBounds { end, text_len } => write!(
formatter,
"text byte range ends at {end}, past the {text_len}-byte value"
),
Self::NotCharBoundary { offset } => {
write!(
formatter,
"text byte offset {offset} is not a UTF-8 boundary"
)
}
}
}
}
impl Error for TextReplacementError {}
fn validate_node_range(
nodes: &[Node<'_>],
range: &Range<usize>,
) -> Result<(), TextReplacementError> {
if range.start >= range.end || range.end > nodes.len() {
return Err(TextReplacementError::InvalidNodeRange {
start: range.start,
end: range.end,
node_count: nodes.len(),
});
}
for (index, node) in nodes.iter().enumerate().take(range.end).skip(range.start) {
if !matches!(node, Node::Text(_)) {
return Err(TextReplacementError::NonTextNode { index });
}
}
Ok(())
}
fn validate_text_byte_range(
nodes: &[Node<'_>],
node_range: &Range<usize>,
byte_range: &Range<usize>,
) -> Result<(), TextReplacementError> {
if byte_range.start > byte_range.end {
return Err(TextReplacementError::ReversedByteRange {
start: byte_range.start,
end: byte_range.end,
});
}
let text_len = text_len_in_range(nodes, node_range);
if byte_range.end > text_len {
return Err(TextReplacementError::ByteRangeOutOfBounds {
end: byte_range.end,
text_len,
});
}
for offset in [byte_range.start, byte_range.end] {
if !is_text_char_boundary(nodes, node_range, offset) {
return Err(TextReplacementError::NotCharBoundary { offset });
}
}
Ok(())
}
fn text_len_in_range(nodes: &[Node<'_>], node_range: &Range<usize>) -> usize {
nodes[node_range.clone()]
.iter()
.map(|node| match node {
Node::Text(text) => text.value.len(),
_ => 0,
})
.sum()
}
fn is_text_char_boundary(nodes: &[Node<'_>], node_range: &Range<usize>, offset: usize) -> bool {
let mut cursor = 0;
for node in &nodes[node_range.clone()] {
let Node::Text(text) = node else {
return false;
};
let end = cursor + text.value.len();
if offset <= end {
return text.value.is_char_boundary(offset - cursor);
}
cursor = end;
}
offset == cursor
}
fn overlapping_text_nodes(
nodes: &[Node<'_>],
node_range: &Range<usize>,
byte_range: &Range<usize>,
) -> Result<(usize, usize, usize, usize), TextReplacementError> {
let mut cursor = 0;
let mut first = None;
let mut last = None;
let mut first_offset = 0;
let mut last_offset = 0;
for index in node_range.clone() {
let Node::Text(text) = &nodes[index] else {
continue;
};
let end = cursor + text.value.len();
if cursor < byte_range.end && end > byte_range.start {
if first.is_none() {
first = Some(index);
first_offset = byte_range.start - cursor;
}
last = Some(index);
last_offset = byte_range.end.min(end) - cursor;
}
cursor = end;
}
let Some(first) = first else {
return Err(TextReplacementError::ByteRangeOutOfBounds {
end: byte_range.end,
text_len: text_len_in_range(nodes, node_range),
});
};
let Some(last) = last else {
return Err(TextReplacementError::ByteRangeOutOfBounds {
end: byte_range.end,
text_len: text_len_in_range(nodes, node_range),
});
};
Ok((first, last, first_offset, last_offset))
}
fn insert_node_at_text_offset<'arena>(
nodes: &mut ferromark::allocator::Vec<'arena, Node<'arena>>,
node_range: &Range<usize>,
offset: usize,
inserted: Node<'arena>,
) {
let text_len = text_len_in_range(nodes, node_range);
if offset == 0 {
drop(nodes.splice(
node_range.start..node_range.start,
std::iter::once(inserted),
));
return;
}
if offset == text_len {
drop(nodes.splice(node_range.end..node_range.end, std::iter::once(inserted)));
return;
}
let mut cursor = 0;
for index in node_range.clone() {
let Node::Text(text) = &nodes[index] else {
continue;
};
let end = cursor + text.value.len();
if cursor < offset && offset < end {
let (prefix, suffix, span) = (
&text.value[..offset - cursor],
&text.value[offset - cursor..],
text.span,
);
let parts = [
Some(Node::Text(Text {
value: prefix,
span,
})),
Some(inserted),
Some(Node::Text(Text {
value: suffix,
span,
})),
];
drop(nodes.splice(index..index + 1, parts.into_iter().flatten()));
return;
}
cursor = end;
if cursor == offset {
drop(nodes.splice(index + 1..index + 1, std::iter::once(inserted)));
return;
}
}
drop(nodes.splice(node_range.end..node_range.end, std::iter::once(inserted)));
}
fn validate_byte_range(value: &str, range: &Range<usize>) -> Result<(), TextReplacementError> {
if range.start > range.end {
return Err(TextReplacementError::ReversedByteRange {
start: range.start,
end: range.end,
});
}
if range.end > value.len() {
return Err(TextReplacementError::ByteRangeOutOfBounds {
end: range.end,
text_len: value.len(),
});
}
for offset in [range.start, range.end] {
if !value.is_char_boundary(offset) {
return Err(TextReplacementError::NotCharBoundary { offset });
}
}
Ok(())
}
fn span_for_byte_range(
nodes: &[Node<'_>],
node_range: &Range<usize>,
byte_range: &Range<usize>,
) -> Span {
if byte_range.is_empty() {
return Span::empty();
}
let mut byte_cursor = 0;
let mut span = None;
for node in nodes.iter().take(node_range.end).skip(node_range.start) {
if let Node::Text(text) = node {
let segment_end = byte_cursor + text.value.len();
if byte_cursor < byte_range.end
&& segment_end > byte_range.start
&& !text.span.is_empty()
{
span = Some(span.map_or(text.span, |current: Span| current.merge(text.span)));
}
byte_cursor = segment_end;
}
}
span.unwrap_or_else(Span::empty)
}
#[derive(Debug)]
pub struct TransformError {
pass_index: usize,
pass_name: &'static str,
source: BoxError,
}
impl TransformError {
#[must_use]
pub const fn pass_index(&self) -> usize {
self.pass_index
}
#[must_use]
pub const fn pass_name(&self) -> &'static str {
self.pass_name
}
}
impl fmt::Display for TransformError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"transform pass {} ({:?}) failed: {}",
self.pass_index, self.pass_name, self.source
)
}
}
impl Error for TransformError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
Some(&*self.source)
}
}