> = Vec::with_capacity(events.len());
+ for event in events.drain(..) {
+ match event {
+ Event::End(end) if is_delimited_end(&end) && is_delimited_start(out.last()) => {
+ out.pop();
+ changed = true;
+ }
+ Event::End(end) if is_delimited_end(&end) && is_break(out.last()) => {
+ let brk = out.pop().expect("checked non-empty");
+ out.push(Event::End(end));
+ out.push(brk);
+ changed = true;
+ }
+ Event::End(end)
+ if is_delimited_end(&end)
+ && matches!(out.last(), Some(Event::Text(t)) if t.ends_with(char::is_whitespace)) =>
+ {
+ let Some(Event::Text(text)) = out.pop() else {
+ unreachable!("checked above")
+ };
+ let body = text.trim_end();
+ let space = text[body.len()..].to_owned();
+ if !body.is_empty() {
+ out.push(Event::Text(CowStr::from(body.to_owned())));
+ }
+ out.push(Event::End(end));
+ out.push(Event::Text(CowStr::from(space)));
+ changed = true;
+ }
+ Event::End(end) if is_block_end(&end) && is_break(out.last()) => {
+ out.pop();
+ out.push(Event::End(end));
+ changed = true;
+ }
+ Event::SoftBreak | Event::HardBreak if is_delimited_start(out.last()) => {
+ let start = out.pop().expect("checked non-empty");
+ out.push(event);
+ out.push(start);
+ changed = true;
+ }
+ Event::SoftBreak | Event::HardBreak if is_block_start(out.last()) => {
+ changed = true;
+ }
+ Event::Text(text)
+ if text.starts_with(char::is_whitespace) && is_delimited_start(out.last()) =>
+ {
+ let start = out.pop().expect("checked non-empty");
+ let body = text.trim_start();
+ let space = text[..text.len() - body.len()].to_owned();
+ out.push(Event::Text(CowStr::from(space)));
+ out.push(start);
+ if !body.is_empty() {
+ out.push(Event::Text(CowStr::from(body.to_owned())));
+ }
+ changed = true;
+ }
+ Event::End(end) if closes_line(&end) && last_text_ends_with_line_space(&out) => {
+ trim_last_text_end(&mut out);
+ out.push(Event::End(end));
+ changed = true;
+ }
+ Event::SoftBreak | Event::HardBreak if last_text_ends_with_line_space(&out) => {
+ trim_last_text_end(&mut out);
+ out.push(event);
+ changed = true;
+ }
+ Event::Text(text) if text.starts_with(is_line_space) && opens_line(out.last()) => {
+ let body = text.trim_start_matches(is_line_space);
+ if !body.is_empty() {
+ out.push(Event::Text(CowStr::from(body.to_owned())));
+ }
+ changed = true;
+ }
+ other => out.push(other),
+ }
+ }
+ *events = out;
+ changed
+}
+
+/// Keeps suppressed raw HTML inert in Markdown output.
+///
+/// `suppress_raw_html` turns `Html` events into `Text` but leaves the
+/// `HtmlBlock` container around them, which is what the HTML renderer
+/// wants (escaped text, no ``). The Markdown serializer, though, writes
+/// an `HtmlBlock`'s contents verbatim, so that text would reparse as live
+/// HTML. Blocks whose contents start with `Text` are rewritten as a
+/// paragraph, one trimmed line per `SoftBreak`, so the serializer escapes
+/// them. Blocks of real `Html` events (`raw_html: true`) pass through.
+struct InertHtmlBlocks<'a, I: Iterator- >> {
+ inner: std::iter::Peekable,
+ pending: VecDeque>,
+}
+
+impl<'a, I: Iterator
- >> InertHtmlBlocks<'a, I> {
+ fn new(inner: I) -> Self {
+ Self {
+ inner: inner.peekable(),
+ pending: VecDeque::new(),
+ }
+ }
+
+ /// Consume the rest of a suppressed HTML block (through its `End`) and
+ /// queue it as a paragraph.
+ fn queue_as_paragraph(&mut self) {
+ let mut lines: Vec = Vec::new();
+ loop {
+ match self.inner.next() {
+ // An `Html` event in a block that was otherwise suppressed
+ // is escaped too: staying inert is the safe default.
+ Some(Event::Text(t)) | Some(Event::Html(t)) => lines.extend(
+ t.split('\n')
+ .map(str::trim)
+ .filter(|l| !l.is_empty())
+ .map(str::to_owned),
+ ),
+ Some(Event::End(TagEnd::HtmlBlock)) | None => break,
+ Some(_) => {}
+ }
+ }
+ if lines.is_empty() {
+ return;
+ }
+ self.pending.push_back(Event::Start(Tag::Paragraph));
+ for (i, line) in lines.into_iter().enumerate() {
+ if i > 0 {
+ self.pending.push_back(Event::SoftBreak);
+ }
+ self.pending.push_back(Event::Text(CowStr::from(line)));
+ }
+ self.pending.push_back(Event::End(TagEnd::Paragraph));
+ }
+}
+
+impl<'a, I: Iterator
- >> Iterator for InertHtmlBlocks<'a, I> {
+ type Item = Event<'a>;
+
+ fn next(&mut self) -> Option> {
+ loop {
+ if let Some(event) = self.pending.pop_front() {
+ return Some(event);
+ }
+ match self.inner.next()? {
+ Event::Start(Tag::HtmlBlock)
+ if matches!(self.inner.peek(), Some(Event::Text(_))) =>
+ {
+ // May queue nothing (all-blank block); loop either way.
+ self.queue_as_paragraph();
+ }
+ event => return Some(event),
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use pulldown_cmark::Parser;
+
+ fn suppressed(source: &str) -> Vec> {
+ Parser::new_ext(source, Options::empty())
+ .map(|e| match e {
+ Event::Html(h) | Event::InlineHtml(h) => Event::Text(h),
+ other => other,
+ })
+ .collect()
+ }
+
+ fn reparse_has_html(markdown: &str) -> bool {
+ Parser::new_ext(markdown, Options::empty())
+ .any(|e| matches!(e, Event::Html(_) | Event::InlineHtml(_)))
+ }
+
+ #[test]
+ fn suppressed_html_block_stays_inert() {
+ let md = render(
+ &suppressed("
\n*inside*\n
\n"),
+ Options::empty(),
+ )
+ .unwrap();
+ assert!(!reparse_has_html(&md), "reparsed as live HTML: {md:?}");
+ assert!(md.contains("div"), "lost the escaped text: {md:?}");
+ }
+
+ #[test]
+ fn suppressed_html_block_drops_blank_lines() {
+ // HTML block types 1-5 (here \n"),
+ Options::empty(),
+ )
+ .unwrap();
+ assert!(!reparse_has_html(&md), "reparsed as live HTML: {md:?}");
+ assert!(md.contains("alert(1)"), "lost the escaped text: {md:?}");
+ }
+
+ #[test]
+ fn live_html_block_passes_through() {
+ let events: Vec =
+ Parser::new_ext("\nraw\n
\n", Options::empty()).collect();
+ let md = render(&events, Options::empty()).unwrap();
+ assert!(md.contains(""), "raw HTML was rewritten: {md:?}");
+ }
+
+ /// Parse `source` and drop every link's Start/End, as the allowlist
+ /// filters do when they unwrap a disallowed link to its text.
+ fn unwrapped_links(source: &str) -> Vec
> {
+ Parser::new_ext(source, Options::empty())
+ .filter(|e| !matches!(e, Event::Start(Tag::Link { .. }) | Event::End(TagEnd::Link)))
+ .collect()
+ }
+
+ #[test]
+ fn unwrapped_link_edges_inside_emphasis_serialize() {
+ for source in [
+ "**[text\n](u)**",
+ "**[\ntext](u)**",
+ "**[text ](u)**",
+ "**[ text](u)**",
+ "**_[text\n](u)_**",
+ "a **[text ](u)** b",
+ ] {
+ let md = render(&unwrapped_links(source), Options::empty())
+ .unwrap_or_else(|e| panic!("{source:?} failed: {e}"));
+ let strong = Parser::new_ext(&md, Options::empty())
+ .any(|e| matches!(e, Event::Start(Tag::Strong)));
+ assert!(strong && md.contains("text"), "{source:?} => {md:?}");
+ }
+ }
+
+ #[test]
+ fn emphasis_emptied_by_unwrapping_is_dropped() {
+ let md = render(&unwrapped_links("a *[](u)* b"), Options::empty()).unwrap();
+ assert!(!md.contains('*'), "{md:?}");
+ }
+
+ #[test]
+ fn unbalanced_events_return_an_error_instead_of_panicking() {
+ let events = vec![
+ Event::Start(Tag::Paragraph),
+ Event::Text(CowStr::Borrowed("x")),
+ Event::End(TagEnd::Paragraph),
+ Event::End(TagEnd::BlockQuote(None)),
+ ];
+ assert!(render(&events, Options::empty()).is_err());
+ }
+}
diff --git a/ext/inkmark/src/scheme_filter.rs b/ext/inkmark/src/scheme_filter.rs
index 159e87f..15b7127 100644
--- a/ext/inkmark/src/scheme_filter.rs
+++ b/ext/inkmark/src/scheme_filter.rs
@@ -35,8 +35,10 @@ pub struct SchemeFilter<'e, 's, I: Iterator- >> {
// disallows nested links so this is usually 1, but the counter keeps
// us correct on malformed / extension-emitted streams.
skipping_link_depth: usize,
- // State for in-progress image drop.
- skipping_image: bool,
+ // State for in-progress image drop, counted like links: an image can
+ // nest in another image's alt text (`](y)`). 0 = not
+ // skipping.
+ skipping_image_depth: usize,
image_alt: String,
}
@@ -51,7 +53,7 @@ impl<'e, 's, I: Iterator
- >> SchemeFilter<'e, 's, I> {
link_allowed,
image_allowed,
skipping_link_depth: 0,
- skipping_image: false,
+ skipping_image_depth: 0,
image_alt: String::new(),
}
}
@@ -63,10 +65,17 @@ impl<'e, 's, I: Iterator
- >> Iterator for SchemeFilter<'e, 's, I>
fn next(&mut self) -> Option> {
loop {
// Image skipping mode
- if self.skipping_image {
+ if self.skipping_image_depth > 0 {
match self.inner.next()? {
+ Event::Start(Tag::Image { .. }) => {
+ self.skipping_image_depth += 1;
+ continue;
+ }
Event::End(TagEnd::Image) => {
- self.skipping_image = false;
+ self.skipping_image_depth -= 1;
+ if self.skipping_image_depth > 0 {
+ continue;
+ }
if !self.image_alt.is_empty() {
let alt = std::mem::take(&mut self.image_alt);
return Some(Event::Text(CowStr::Boxed(alt.into_boxed_str())));
@@ -117,7 +126,7 @@ impl<'e, 's, I: Iterator
- >> Iterator for SchemeFilter<'e, 's, I>
.image_allowed
.is_some_and(|s| !is_scheme_allowed(dest_url, s)) =>
{
- self.skipping_image = true;
+ self.skipping_image_depth = 1;
self.image_alt.clear();
continue;
}
@@ -162,6 +171,22 @@ mod tests {
assert!(matches!(out[0], Event::Start(Tag::Link { .. })));
}
+ #[test]
+ fn drops_blocked_image_with_an_image_nested_in_its_alt_text() {
+ let source = "](http://x.com/2)";
+ let events: Vec = pulldown_cmark::Parser::new(source).collect();
+ let allowed = schemes(&["https"]);
+ let out = run(events, None, Some(&allowed));
+ assert!(
+ !out.iter().any(|e| matches!(
+ e,
+ Event::Start(Tag::Image { .. }) | Event::End(TagEnd::Image)
+ )),
+ "stray image event: {out:?}"
+ );
+ assert!(out.contains(&Event::Text(CowStr::Borrowed("foo bar"))));
+ }
+
#[test]
fn drops_blocked_link_keeps_text() {
let events = vec![
diff --git a/ext/inkmark/src/truncate.rs b/ext/inkmark/src/truncate.rs
index bafa5cc..93b0936 100644
--- a/ext/inkmark/src/truncate.rs
+++ b/ext/inkmark/src/truncate.rs
@@ -11,6 +11,7 @@ use pulldown_cmark::Event;
use unicode_segmentation::UnicodeSegmentation;
use crate::document::{apply_filters, content_events};
+use crate::markdown::{self, SerializeError};
use crate::options::{build_options, Flags};
/// What kind of boundary to cut at.
@@ -43,10 +44,14 @@ pub fn truncate_source(
cm_opts: pulldown_cmark::Options,
flags: &Flags,
params: &TruncateParams,
-) -> String {
+) -> Result {
let events: Vec = content_events(source, cm_opts).collect();
let events = apply_filters(events, flags);
- truncate_events(&events, params)
+ truncate_events(
+ &events,
+ params,
+ markdown::serializer_options(cm_opts, flags),
+ )
}
/// Ruby-facing entry point. Expects `params_hash` to contain
@@ -61,7 +66,7 @@ pub fn native_truncate_markdown(
) -> Result {
let (cm_opts, flags) = build_options(ruby, opts_hash)?;
let params = parse_params(ruby, params_hash)?;
- Ok(truncate_source(&source, cm_opts, &flags, ¶ms))
+ truncate_source(&source, cm_opts, &flags, ¶ms).map_err(|e| markdown::to_ruby_error(ruby, e))
}
pub fn parse_params(ruby: &Ruby, hash: RHash) -> Result {
@@ -85,14 +90,22 @@ pub fn parse_params(ruby: &Ruby, hash: RHash) -> Result {
}
/// Core truncation over a filter-applied event slice.
-pub fn truncate_events(events: &[Event<'_>], params: &TruncateParams) -> String {
+pub fn truncate_events(
+ events: &[Event<'_>],
+ params: &TruncateParams,
+ md_opts: pulldown_cmark::Options,
+) -> Result {
match params.at {
- TruncateAt::Block => truncate_at_block(events, params),
- TruncateAt::Word => truncate_at_word(events, params),
+ TruncateAt::Block => truncate_at_block(events, params, md_opts),
+ TruncateAt::Word => truncate_at_word(events, params, md_opts),
}
}
-fn truncate_at_block(events: &[Event<'_>], params: &TruncateParams) -> String {
+fn truncate_at_block(
+ events: &[Event<'_>],
+ params: &TruncateParams,
+ md_opts: pulldown_cmark::Options,
+) -> Result {
let marker_chars = marker_chars(¶ms.marker);
let marker_words = marker_words(¶ms.marker);
let char_budget = params.chars.map(|n| n.saturating_sub(marker_chars));
@@ -104,8 +117,14 @@ fn truncate_at_block(events: &[Event<'_>], params: &TruncateParams) -> String {
let mut any_dropped = false;
for (start, end) in top_level_blocks(events) {
- let block = render_markdown(&events[start..=end]);
- let block_chars = block.trim_end().chars().count();
+ let block = markdown::render_block(&events[start..=end], md_opts)?;
+ // The blank line rejoining blocks counts toward the char budget.
+ let separator = if kept.is_empty() {
+ ""
+ } else {
+ markdown::BLOCK_SEPARATOR
+ };
+ let block_chars = separator.len() + block.trim_end().chars().count();
let block_words = block.unicode_words().count();
let would_exceed_chars = char_budget
@@ -120,6 +139,7 @@ fn truncate_at_block(events: &[Event<'_>], params: &TruncateParams) -> String {
break;
}
+ kept.push_str(separator);
kept.push_str(&block);
used_chars += block_chars;
used_words += block_words;
@@ -127,12 +147,12 @@ fn truncate_at_block(events: &[Event<'_>], params: &TruncateParams) -> String {
// If nothing was dropped and source fit, return unchanged (no marker).
if !any_dropped {
- return kept;
+ return Ok(kept);
}
// First block alone exceeded the budget; honest empty return
if kept.is_empty() {
- return String::new();
+ return Ok(String::new());
}
// Trim trailing whitespace before appending the marker so the
@@ -145,7 +165,7 @@ fn truncate_at_block(events: &[Event<'_>], params: &TruncateParams) -> String {
kept.push_str(marker);
}
kept.push('\n');
- kept
+ Ok(kept)
}
/// Return (start, end) event-index pairs for top-level blocks.
@@ -185,15 +205,12 @@ fn top_level_blocks(events: &[Event<'_>]) -> Vec<(usize, usize)> {
blocks
}
-fn render_markdown(events: &[Event<'_>]) -> String {
- let mut buf = String::new();
- pulldown_cmark_to_cmark::cmark(events.iter().cloned(), &mut buf)
- .expect("markdown serialization failed");
- buf
-}
-
-fn truncate_at_word(events: &[Event<'_>], params: &TruncateParams) -> String {
- let rendered = render_markdown(events);
+fn truncate_at_word(
+ events: &[Event<'_>],
+ params: &TruncateParams,
+ md_opts: pulldown_cmark::Options,
+) -> Result {
+ let rendered = markdown::render(events, md_opts)?;
let marker_chars = marker_chars(¶ms.marker);
let marker_words = marker_words(¶ms.marker);
@@ -211,7 +228,7 @@ fn truncate_at_word(events: &[Event<'_>], params: &TruncateParams) -> String {
// Fits under both budgets: return unchanged, no marker.
if chars_ok && words_ok {
- return rendered;
+ return Ok(rendered);
}
let char_budget = params.chars.map(|n| n.saturating_sub(marker_chars));
@@ -252,7 +269,7 @@ fn truncate_at_word(events: &[Event<'_>], params: &TruncateParams) -> String {
if let Some(marker) = ¶ms.marker {
out.push_str(marker);
}
- out
+ Ok(out)
}
fn marker_chars(marker: &Option) -> usize {
diff --git a/spec/inkmark_spec.rb b/spec/inkmark_spec.rb
index 528fed3..e2d353f 100644
--- a/spec/inkmark_spec.rb
+++ b/spec/inkmark_spec.rb
@@ -941,6 +941,11 @@
expect(html).to include('loading="lazy"')
end
+ it "treats an image nested in another image's alt text as alt text" do
+ md = described_class.to_markdown("](/url2)", options: {images: {lazy: true}})
+ expect(md).to eq(%(
))
+ end
+
it "escapes HTML specials in alt text" do
html = described_class.to_html('', options: {images: {lazy: true}})
expect(html).to include(""")
@@ -1082,6 +1087,46 @@
end
end
+ context "in Markdown output by default" do
+ let(:source) { "\n*inside*\n
\n\npara" }
+
+ def live_div?(markdown)
+ described_class.to_html(markdown, options: {raw_html: true}).include?("<!-- foo -->")
+ expect(html).not_to match(/^