dprint-plugin-markdown 0.21.1

Markdown formatter for dprint.
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

use super::parse_link_url_and_title;
use super::parse_text_in_brackets;
use super::parse_text_in_parens;
use crate::generation::common::*;
use pulldown_cmark::LinkType;

/// Crudely parses out an image assuming the text is an image.
/// This is done because images have their references inlined by cmark.
pub fn parse_image(offset: usize, text: &str, link_type: LinkType) -> Result<Node, ParseError> {
  let mut char_scanner = CharScanner::new(offset, text);
  let start_pos = char_scanner.pos();

  match link_type {
    LinkType::Inline => parse_inline(start_pos, &mut char_scanner),
    LinkType::Reference | LinkType::ReferenceUnknown | LinkType::Collapsed | LinkType::CollapsedUnknown => {
      parse_reference(start_pos, &mut char_scanner)
    }
    LinkType::Shortcut | LinkType::ShortcutUnknown | LinkType::Email | LinkType::Autolink => Err(ParseError::new(
      Range {
        start: offset,
        end: offset,
      },
      format!("Link type not implemented {:?}", link_type),
    )),
  }
}

fn parse_inline(start_pos: usize, char_scanner: &mut CharScanner) -> Result<Node, ParseError> {
  char_scanner.assert_char('!')?;
  char_scanner.assert_char('[')?;
  let text = parse_text_in_brackets(start_pos, char_scanner)?;
  char_scanner.assert_char('(')?;
  let paren_text = parse_text_in_parens(start_pos, char_scanner)?;
  let (url, title) = parse_link_url_and_title(paren_text.trim());

  Ok(
    InlineImage {
      range: Range {
        start: start_pos,
        end: char_scanner.end(),
      },
      text,
      url,
      title,
    }
    .into(),
  )
}

fn parse_reference(start_pos: usize, char_scanner: &mut CharScanner) -> Result<Node, ParseError> {
  char_scanner.assert_char('!')?;
  char_scanner.assert_char('[')?;
  let text = parse_text_in_brackets(start_pos, char_scanner)?;
  char_scanner.assert_char('[')?;
  let reference = parse_text_in_brackets(start_pos, char_scanner)?;

  Ok(
    ReferenceImage {
      range: Range {
        start: start_pos,
        end: char_scanner.end(),
      },
      text,
      reference,
    }
    .into(),
  )
}

#[cfg(test)]
mod test {
  use super::*;

  #[test]
  fn it_should_parse_image() {
    let result = parse_image(10, "![text](url)\n", LinkType::Inline);
    assert_eq!(result.is_ok(), true);
    let image = result.ok().unwrap();
    assert_eq!(image.range().start, 10);
    assert_eq!(image.range().end, 22);
  }
}