迷你拉取式解析器

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tag {
  Paragraph,
  Heading(u8),
  Emphasis,
  Strong,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Event<'a> {
  Start(Tag),
  End(Tag),
  Text(Cow<'a, str>),
  Code(Cow<'a, str>),
  SoftBreak,
  HardBreak,
}

pub struct Parser<'a> {
  src: &'a str,
  pos: usize,
  queue: VecDeque<Event<'a>>,
}

impl<'a> Iterator for Parser<'a> {
  type Item = Event<'a>;

  fn next(&mut self) -> Option<Event<'a>> {
    if self.queue.is_empty() && !self.parse_block() {
      return None;
    }
    self.queue.pop_front()
  }
}

  fn parse_block(&mut self) -> bool {
    while let Some((line, next)) = line_at(self.src, self.pos) {
      if is_blank(line) {
        self.pos = next;
        continue;
      }
      if let Some((level, content)) = atx_heading(line) {
        self.pos = next;
        self.push_block(Tag::Heading(level), content);
        return true;
      }
      // A paragraph runs until a blank line or a heading.
      let start = self.pos + (line.len() - line.trim_start_matches([' ', '\t']).len());
      let mut end = self.pos + line.len();
      self.pos = next;
      while let Some((line, next)) = line_at(self.src, self.pos) {
        if is_blank(line) || atx_heading(line).is_some() {
          break;
        }
        end = self.pos + line.len();
        self.pos = next;
      }
      let content = self.src[start..end].trim_end_matches([' ', '\t']);
      self.push_block(Tag::Paragraph, content);
      return true;
    }
    false
  }

struct Delim<'a> {
  run: &'a str,
  count: usize,
  used_left: usize,
  can_open: bool,
  can_close: bool,
  ends: Vec<Tag>,
  starts: Vec<Tag>,
}

enum Node<'a> {
  Event(Event<'a>),
  Delim(Delim<'a>),
}

      b'`' => {
        let n = run_len(b, i, b'`');
        if let Some(close) = find_backticks(b, i + n, n) {
          push_text(s, text_start, i, &mut nodes);
          nodes.push(Node::Event(Event::Code(code_content(&s[i + n..close]))));
          i = close + n;
          text_start = i;
        } else {
          i += n; // no closer: the backticks stay in the text
        }
      }
      b'*' => {
        let n = run_len(b, i, b'*');
        push_text(s, text_start, i, &mut nodes);
        let (can_open, can_close) = flanking(s[..i].chars().next_back(), s[i + n..].chars().next());
        nodes.push(Node::Delim(Delim {
          run: &s[i..i + n],
          // ...
        }));
        i += n;
        text_start = i;
      }
      b'\n' => {
        let mut end = i;
        while end > text_start && b[end - 1] == b' ' {
          end -= 1;
        }
        push_text(s, text_start, end, &mut nodes);
        let brk = if i - end >= 2 { Event::HardBreak } else { Event::SoftBreak };
        nodes.push(Node::Event(brk));
        i = skip_indent(b, i + 1);
        text_start = i;
      }

fn is_punct(c: char) -> bool {
  c.is_ascii_punctuation() || (!c.is_ascii() && !c.is_alphanumeric() && !c.is_whitespace())
}

/// (left-flanking, right-flanking); the text edges count as whitespace.
fn flanking(prev: Option<char>, next: Option<char>) -> (bool, bool) {
  let ws = |c: Option<char>| c.map_or(true, char::is_whitespace);
  let punct = |c: Option<char>| c.is_some_and(is_punct);
  let left = !ws(next) && (!punct(next) || ws(prev) || punct(prev));
  let right = !ws(prev) && (!punct(prev) || ws(next) || punct(next));
  (left, right)
}

fn process_emphasis(nodes: &mut [Node]) {
  let mut stack: Vec<usize> = Vec::new();
  for ci in 0..nodes.len() {
    if !matches!(nodes[ci], Node::Delim(_)) {
      continue;
    }
    while delim(nodes, ci).can_close && delim(nodes, ci).count > 0 {
      let (c_run, c_open) = (delim(nodes, ci).run.len(), delim(nodes, ci).can_open);
      let found = stack.iter().rposition(|&oi| {
        let o = match &nodes[oi] {
          Node::Delim(o) => o,
          Node::Event(_) => return false,
        };
        // The "multiple of 3" rule.
        let sum = o.run.len() + c_run;
        !((o.can_close || c_open) && sum % 3 == 0 && !(o.run.len() % 3 == 0 && c_run % 3 == 0))
      });
      let Some(si) = found else { break };
      let oi = stack[si];
      let n = if delim(nodes, oi).count >= 2 && delim(nodes, ci).count >= 2 { 2 } else { 1 };
      let tag = if n == 2 { Tag::Strong } else { Tag::Emphasis };
      let opener = delim(nodes, oi);
      opener.count -= n;
      opener.starts.insert(0, tag); // later matches wrap the earlier ones
      let opener_done = opener.count == 0;
      let closer = delim(nodes, ci);
      closer.count -= n;
      closer.used_left += n;
      closer.ends.push(tag);
      stack.truncate(si + 1); // delimiters in between become text
      if opener_done {
        stack.pop();
      }
    }
    let d = delim(nodes, ci);
    if d.can_open && d.count > 0 {
      stack.push(ci);
    }
  }
}

"***foo** bar*\n"
ours   [Start(Paragraph), Start(Emphasis), Start(Strong), Text("foo"), End(Strong), Text(" bar"), End(Emphasis), End(Paragraph)]
theirs [Start(Paragraph), Start(Emphasis), Start(Strong), Text("foo"), End(Strong), Text(" bar"), End(Emphasis), End(Paragraph)]
"foo******bar*********baz\n"
ours   [Start(Paragraph), Text("foo"), Start(Strong), Start(Strong), Start(Strong), Text("bar"), End(Strong), End(Strong), End(Strong), Text("***baz"), End(Paragraph)]
theirs [Start(Paragraph), Text("foo"), Start(Strong), Start(Strong), Start(Strong), Text("bar"), End(Strong), End(Strong), End(Strong), Text("***baz"), End(Paragraph)]

fn from_pd(e: pd::Event<'_>) -> Event<'static> {
  let tag = |t: pd::TagEnd| match t {
    pd::TagEnd::Paragraph => Some(Tag::Paragraph),
    pd::TagEnd::Heading(l) => Some(Tag::Heading(l as u8)),
    pd::TagEnd::Emphasis => Some(Tag::Emphasis),
    pd::TagEnd::Strong => Some(Tag::Strong),
    _ => None,
  };
  match e {
    pd::Event::Start(t) => match tag(t.to_end()) {
      Some(t) => Event::Start(t),
      None => Event::Text(Cow::Owned(format!("<unsupported {t:?}>"))),
    },
    // ...
    other => Event::Text(Cow::Owned(format!("<unsupported {other:?}>"))),
  }
}

/// Merges adjacent Text events and drops empty ones: both parsers split text
/// at different places (escapes, leftover delimiters).
fn merge(events: impl Iterator<Item = Event<'static>>) -> Vec<Event<'static>> {
  let mut out: Vec<Event> = Vec::new();
  for e in events {
    match (out.last_mut(), e) {
      (_, Event::Text(t)) if t.is_empty() => {}
      (Some(Event::Text(prev)), Event::Text(t)) => prev.to_mut().push_str(&t),
      (_, e) => out.push(e),
    }
  }
  out
}

const CHOSEN: [usize; 30] = [
  // ATX headings
  62, 63, 64, 66, 68, 71, 75, 76,
  // Paragraphs
  219, 220, 222, 226,
  // Code spans
  328, 329, 335, 338, 341, 347,
  // Emphasis and strong emphasis
  350, 351, 355, 369, 411, 413, 417, 418, 445, 478,
  // Hard line breaks
  633, 634,
];

running 3 tests
test show ... ignored
ATX headings: 18 examples, 16 match, 2 use unsupported syntax, 0 real mismatches []
test chosen_examples_match_pulldown_cmark ... ok
Paragraphs: 8 examples, 7 match, 1 use unsupported syntax, 0 real mismatches []
Code spans: 22 examples, 20 match, 2 use unsupported syntax, 0 real mismatches []
Emphasis and strong emphasis: 132 examples, 87 match, 45 use unsupported syntax, 0 real mismatches []
Hard line breaks: 15 examples, 13 match, 2 use unsupported syntax, 0 real mismatches []
Soft line breaks: 2 examples, 2 match, 0 use unsupported syntax, 0 real mismatches []
test survey ... ok

test result: ok. 2 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.01s

thread 'chosen_examples_match_pulldown_cmark' (7467206) panicked at tests/spec.rs:119:3:
mismatch: [411]
...
Emphasis and strong emphasis: 132 examples, 83 match, 45 use unsupported syntax, 4 real mismatches [411, 412, 415, 429]
...
test result: FAILED. 0 passed; 2 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.01s