asciidork-parser 0.38.1

Asciidork parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use bumpalo::collections::CollectIn;

use crate::internal::*;

impl<'arena> Parser<'arena> {
  pub(crate) fn parse_book_part(&mut self) -> Result<Option<Part<'arena>>> {
    let Some(peeked) = self.peek_section()? else {
      return Ok(None);
    };

    if peeked.authored_level != 0 || peeked.is_special_sect() {
      self.restore_peeked_section(peeked);
      return Ok(None);
    }

    let PeekedSection {
      meta,
      mut lines,
      authored_level,
      semantic_level,
    } = peeked;
    let mut heading_line = lines.consume_current().unwrap();
    let equals = heading_line.consume_current().unwrap();
    heading_line.discard_assert(TokenKind::Whitespace);
    let id = self.section_id(&heading_line, &meta.attrs);
    let heading = self.parse_inlines(&mut heading_line.into_lines())?;
    self.push_toc_node(
      authored_level,
      semantic_level,
      &heading,
      id.as_ref(),
      meta.attrs.special_sect(),
    );

    if let Some(id) = &id {
      self.document.anchors.borrow_mut().insert(
        id.clone(),
        Anchor {
          reftext: None,
          title: heading.clone(),
          source_loc: None,
          source_idx: self.lexer.source_idx(),
          is_biblio: false,
        },
      );
    }

    let mut title = PartTitle { meta, text: heading, id };
    let Sectioned { mut preamble, sections } = self.parse_sectioned()?;

    if sections.is_empty() {
      self.err_line_starting(
        "Invalid empty book part, must have at least one section",
        equals.loc,
      )?;
    }

    // asciidoctor wraps the part intro in an open block, so if it is manually
    // wrapped already in a single open block, transpose it to be the preamble
    if let Some(
      [
        Block {
          content: BlockContent::Compound(blocks),
          context: BlockContext::Open,
          ..
        },
      ],
    ) = preamble.as_deref_mut()
    {
      preamble = Some(blocks.drain(..).collect_in(self.bump));
    }

    // match asciidoctor behavior of hoisting the title from the first preamble block
    // @see https://github.com/asciidoctor/asciidoctor/issues/4450
    if let Some(ref mut preamble) = preamble {
      let intro_title = preamble
        .first_mut()
        .filter(|block| block.meta.attrs.has_str_positional("partintro"))
        .and_then(|block| block.meta.dot_line_title.take());
      if title.meta.dot_line_title.is_none() {
        title.meta.dot_line_title = intro_title;
      }
    }

    Ok(Some(Part { title, intro: preamble, sections }))
  }
}