326 lines
10 KiB
Rust
326 lines
10 KiB
Rust
//! Parse and display Markdown.
|
|
//!
|
|
//! You can enable the `highlighter` feature for syntax highligting
|
|
//! in code blocks.
|
|
//!
|
|
//! Only the variants of [`Item`] are currently supported.
|
|
use crate::core::font::{self, Font};
|
|
use crate::core::padding;
|
|
use crate::core::theme::{self, Theme};
|
|
use crate::core::{self, Element, Length};
|
|
use crate::{column, container, rich_text, row, span, text};
|
|
|
|
/// A Markdown item.
|
|
#[derive(Debug, Clone)]
|
|
pub enum Item {
|
|
/// A heading.
|
|
Heading(Vec<text::Span<'static, String>>),
|
|
/// A paragraph.
|
|
Paragraph(Vec<text::Span<'static, String>>),
|
|
/// A code block.
|
|
///
|
|
/// You can enable the `highlighter` feature for syntax highligting.
|
|
CodeBlock(Vec<text::Span<'static, String>>),
|
|
/// A list.
|
|
List {
|
|
/// The first number of the list, if it is ordered.
|
|
start: Option<u64>,
|
|
/// The items of the list.
|
|
items: Vec<Vec<Item>>,
|
|
},
|
|
}
|
|
|
|
/// Parse the given Markdown content.
|
|
pub fn parse(
|
|
markdown: &str,
|
|
palette: theme::Palette,
|
|
) -> impl Iterator<Item = Item> + '_ {
|
|
struct List {
|
|
start: Option<u64>,
|
|
items: Vec<Vec<Item>>,
|
|
}
|
|
|
|
let mut spans = Vec::new();
|
|
let mut heading = None;
|
|
let mut strong = false;
|
|
let mut emphasis = false;
|
|
let mut metadata = false;
|
|
let mut table = false;
|
|
let mut link = None;
|
|
let mut lists = Vec::new();
|
|
|
|
#[cfg(feature = "highlighter")]
|
|
let mut highlighter = None;
|
|
|
|
let parser = pulldown_cmark::Parser::new_ext(
|
|
markdown,
|
|
pulldown_cmark::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS
|
|
| pulldown_cmark::Options::ENABLE_PLUSES_DELIMITED_METADATA_BLOCKS
|
|
| pulldown_cmark::Options::ENABLE_TABLES,
|
|
);
|
|
|
|
let produce = |lists: &mut Vec<List>, item| {
|
|
if lists.is_empty() {
|
|
Some(item)
|
|
} else {
|
|
lists
|
|
.last_mut()
|
|
.expect("list context")
|
|
.items
|
|
.last_mut()
|
|
.expect("item context")
|
|
.push(item);
|
|
|
|
None
|
|
}
|
|
};
|
|
|
|
// We want to keep the `spans` capacity
|
|
#[allow(clippy::drain_collect)]
|
|
parser.filter_map(move |event| match event {
|
|
pulldown_cmark::Event::Start(tag) => match tag {
|
|
pulldown_cmark::Tag::Heading { level, .. }
|
|
if !metadata && !table =>
|
|
{
|
|
heading = Some(level);
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::Strong if !metadata && !table => {
|
|
strong = true;
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::Emphasis if !metadata && !table => {
|
|
emphasis = true;
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::Link { dest_url, .. }
|
|
if !metadata && !table =>
|
|
{
|
|
link = Some(dest_url);
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::List(first_item) if !metadata && !table => {
|
|
lists.push(List {
|
|
start: first_item,
|
|
items: Vec::new(),
|
|
});
|
|
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::Item => {
|
|
lists.last_mut().expect("List").items.push(Vec::new());
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::CodeBlock(
|
|
pulldown_cmark::CodeBlockKind::Fenced(_language),
|
|
) if !metadata && !table => {
|
|
#[cfg(feature = "highlighter")]
|
|
{
|
|
use iced_highlighter::{self, Highlighter};
|
|
use text::Highlighter as _;
|
|
|
|
highlighter =
|
|
Some(Highlighter::new(&iced_highlighter::Settings {
|
|
theme: iced_highlighter::Theme::Base16Ocean,
|
|
token: _language.to_string(),
|
|
}));
|
|
}
|
|
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::MetadataBlock(_) => {
|
|
metadata = true;
|
|
None
|
|
}
|
|
pulldown_cmark::Tag::Table(_) => {
|
|
table = true;
|
|
None
|
|
}
|
|
_ => None,
|
|
},
|
|
pulldown_cmark::Event::End(tag) => match tag {
|
|
pulldown_cmark::TagEnd::Heading(_) if !metadata && !table => {
|
|
heading = None;
|
|
produce(&mut lists, Item::Heading(spans.drain(..).collect()))
|
|
}
|
|
pulldown_cmark::TagEnd::Emphasis if !metadata && !table => {
|
|
emphasis = false;
|
|
None
|
|
}
|
|
pulldown_cmark::TagEnd::Strong if !metadata && !table => {
|
|
strong = false;
|
|
None
|
|
}
|
|
pulldown_cmark::TagEnd::Link if !metadata && !table => {
|
|
link = None;
|
|
None
|
|
}
|
|
pulldown_cmark::TagEnd::Paragraph if !metadata && !table => {
|
|
produce(&mut lists, Item::Paragraph(spans.drain(..).collect()))
|
|
}
|
|
pulldown_cmark::TagEnd::Item if !metadata && !table => {
|
|
if spans.is_empty() {
|
|
None
|
|
} else {
|
|
produce(
|
|
&mut lists,
|
|
Item::Paragraph(spans.drain(..).collect()),
|
|
)
|
|
}
|
|
}
|
|
pulldown_cmark::TagEnd::List(_) if !metadata && !table => {
|
|
let list = lists.pop().expect("List");
|
|
|
|
produce(
|
|
&mut lists,
|
|
Item::List {
|
|
start: list.start,
|
|
items: list.items,
|
|
},
|
|
)
|
|
}
|
|
pulldown_cmark::TagEnd::CodeBlock if !metadata && !table => {
|
|
#[cfg(feature = "highlighter")]
|
|
{
|
|
highlighter = None;
|
|
}
|
|
|
|
produce(&mut lists, Item::CodeBlock(spans.drain(..).collect()))
|
|
}
|
|
pulldown_cmark::TagEnd::MetadataBlock(_) => {
|
|
metadata = false;
|
|
None
|
|
}
|
|
pulldown_cmark::TagEnd::Table => {
|
|
table = false;
|
|
None
|
|
}
|
|
_ => None,
|
|
},
|
|
pulldown_cmark::Event::Text(text) if !metadata && !table => {
|
|
#[cfg(feature = "highlighter")]
|
|
if let Some(highlighter) = &mut highlighter {
|
|
use text::Highlighter as _;
|
|
|
|
for (range, highlight) in
|
|
highlighter.highlight_line(text.as_ref())
|
|
{
|
|
let span = span(text[range].to_owned())
|
|
.color_maybe(highlight.color())
|
|
.font_maybe(highlight.font());
|
|
|
|
spans.push(span);
|
|
}
|
|
|
|
return None;
|
|
}
|
|
|
|
let span = span(text.into_string());
|
|
|
|
let span = match heading {
|
|
None => span,
|
|
Some(heading) => span.size(match heading {
|
|
pulldown_cmark::HeadingLevel::H1 => 32,
|
|
pulldown_cmark::HeadingLevel::H2 => 28,
|
|
pulldown_cmark::HeadingLevel::H3 => 24,
|
|
pulldown_cmark::HeadingLevel::H4 => 20,
|
|
pulldown_cmark::HeadingLevel::H5 => 16,
|
|
pulldown_cmark::HeadingLevel::H6 => 16,
|
|
}),
|
|
};
|
|
|
|
let span = if strong || emphasis {
|
|
span.font(Font {
|
|
weight: if strong {
|
|
font::Weight::Bold
|
|
} else {
|
|
font::Weight::Normal
|
|
},
|
|
style: if emphasis {
|
|
font::Style::Italic
|
|
} else {
|
|
font::Style::Normal
|
|
},
|
|
..Font::default()
|
|
})
|
|
} else {
|
|
span
|
|
};
|
|
|
|
let span = if let Some(link) = link.as_ref() {
|
|
span.color(palette.primary).link(link.to_string())
|
|
} else {
|
|
span
|
|
};
|
|
|
|
spans.push(span);
|
|
|
|
None
|
|
}
|
|
pulldown_cmark::Event::Code(code) if !metadata && !table => {
|
|
spans.push(span(code.into_string()).font(Font::MONOSPACE));
|
|
None
|
|
}
|
|
pulldown_cmark::Event::SoftBreak if !metadata && !table => {
|
|
spans.push(span(" "));
|
|
None
|
|
}
|
|
pulldown_cmark::Event::HardBreak if !metadata && !table => {
|
|
spans.push(span("\n"));
|
|
None
|
|
}
|
|
_ => None,
|
|
})
|
|
}
|
|
|
|
/// Display a bunch of Markdown items.
|
|
///
|
|
/// You can obtain the items with [`parse`].
|
|
pub fn view<'a, Message, Renderer>(
|
|
items: impl IntoIterator<Item = &'a Item>,
|
|
on_link: impl Fn(String) -> Message + Copy + 'a,
|
|
) -> Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Message: 'a,
|
|
Renderer: core::text::Renderer<Font = Font> + 'a,
|
|
{
|
|
let blocks = items.into_iter().enumerate().map(|(i, item)| match item {
|
|
Item::Heading(heading) => {
|
|
container(rich_text(heading).on_link(on_link))
|
|
.padding(padding::top(if i > 0 { 8 } else { 0 }))
|
|
.into()
|
|
}
|
|
Item::Paragraph(paragraph) => {
|
|
rich_text(paragraph).on_link(on_link).into()
|
|
}
|
|
Item::List { start: None, items } => {
|
|
column(items.iter().map(|items| {
|
|
row!["•", view(items, on_link)].spacing(10).into()
|
|
}))
|
|
.spacing(10)
|
|
.into()
|
|
}
|
|
Item::List {
|
|
start: Some(start),
|
|
items,
|
|
} => column(items.iter().enumerate().map(|(i, items)| {
|
|
row![text!("{}.", i as u64 + *start), view(items, on_link)]
|
|
.spacing(10)
|
|
.into()
|
|
}))
|
|
.spacing(10)
|
|
.into(),
|
|
Item::CodeBlock(code) => container(
|
|
rich_text(code)
|
|
.font(Font::MONOSPACE)
|
|
.size(12)
|
|
.on_link(on_link),
|
|
)
|
|
.width(Length::Fill)
|
|
.padding(10)
|
|
.style(container::rounded_box)
|
|
.into(),
|
|
});
|
|
|
|
Element::new(column(blocks).width(Length::Fill).spacing(16))
|
|
}
|