docspec 1.7.1

Streaming document conversion: convenience facade re-exporting readers, writers, and event types
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Integration tests for the enum-dispatch reader factory.

#![allow(clippy::expect_used, clippy::unwrap_used)]

#[cfg(test)]
mod tests {
    #[cfg(any(feature = "markdown", feature = "html"))]
    use docspec::{AnyReader, InputFormat};
    #[cfg(any(feature = "markdown", feature = "html"))]
    use docspec_core::EventSource;

    #[cfg(feature = "markdown")]
    #[test]
    fn markdown_dispatch_emits_first_event() {
        use docspec_markdown_reader::MarkdownReader;

        let mut reader = AnyReader::from_str(InputFormat::Markdown, "# h").unwrap();
        let event = reader.next_event().expect("AnyReader should not fail");
        let expected = MarkdownReader::from_str("# h")
            .next_event()
            .expect("direct reader should not fail");
        assert_eq!(event, expected);
    }

    #[cfg(feature = "html")]
    #[test]
    fn html_dispatch_emits_first_event() {
        use docspec_html_reader::HtmlReader;

        let mut reader = AnyReader::from_str(InputFormat::Html, "<p>x</p>").unwrap();
        let event = reader.next_event().expect("AnyReader should not fail");
        let expected = HtmlReader::from_str("<p>x</p>")
            .next_event()
            .expect("direct reader should not fail");
        assert_eq!(event, expected);
    }

    #[cfg(feature = "markdown")]
    #[test]
    fn roundtrip_full_document_markdown() {
        use docspec_markdown_reader::MarkdownReader;

        let input = "# Hello\n\nWorld";
        let mut any_reader = AnyReader::from_str(InputFormat::Markdown, input).unwrap();
        let mut direct_reader = MarkdownReader::from_str(input);
        loop {
            let any_event = any_reader.next_event().expect("AnyReader failed");
            let direct_event = direct_reader.next_event().expect("MarkdownReader failed");
            assert_eq!(any_event, direct_event, "event mismatch");
            if any_event.is_none() {
                break;
            }
        }
    }

    #[cfg(feature = "html")]
    #[test]
    fn roundtrip_full_document_html() {
        use docspec_html_reader::HtmlReader;

        let input = "<p>hello</p>";
        let mut any_reader = AnyReader::from_str(InputFormat::Html, input).unwrap();
        let mut direct_reader = HtmlReader::from_str(input);
        loop {
            let any_event = any_reader.next_event().expect("AnyReader failed");
            let direct_event = direct_reader.next_event().expect("HtmlReader failed");
            assert_eq!(any_event, direct_event, "event mismatch");
            if any_event.is_none() {
                break;
            }
        }
    }

    #[cfg(feature = "markdown")]
    #[test]
    fn assert_is_event_source() {
        fn check<S: EventSource>(_: S) {}
        check(AnyReader::from_str(InputFormat::Markdown, "").unwrap());
    }

    #[cfg(feature = "html")]
    #[test]
    fn html_assert_is_event_source() {
        fn check<S: EventSource>(_: S) {}
        check(AnyReader::from_str(InputFormat::Html, "").unwrap());
    }

    #[cfg(feature = "markdown")]
    #[test]
    fn any_reader_from_reader_matches_from_str_markdown() {
        use std::io::Cursor;

        let input = "# Hello\n\nWorld";
        let mut r1 = AnyReader::from_str(InputFormat::Markdown, input).unwrap();
        let mut r2 =
            AnyReader::from_reader(InputFormat::Markdown, Cursor::new(input.as_bytes())).unwrap();
        let events1: Vec<_> = core::iter::from_fn(|| r1.next_event().unwrap()).collect();
        let events2: Vec<_> = core::iter::from_fn(|| r2.next_event().unwrap()).collect();
        assert_eq!(events1, events2);
    }

    #[cfg(feature = "markdown")]
    #[test]
    fn any_reader_from_reader_strips_bom_markdown() {
        use docspec_core::Event;
        use std::io::Cursor;

        let input = b"\xEF\xBB\xBF# Hello".to_vec();
        let mut reader = AnyReader::from_reader(InputFormat::Markdown, Cursor::new(input))
            .expect("from_reader succeeds");

        let events: Vec<_> = core::iter::from_fn(|| reader.next_event().unwrap()).collect();
        let has_heading = events
            .iter()
            .any(|event| matches!(event, Event::StartHeading { .. }));
        assert!(
            has_heading,
            "expected StartHeading event after BOM strip; events: {events:?}"
        );

        let bom_in_text = events.iter().any(|event| match event {
            Event::Text { content, .. } => content.starts_with('\u{FEFF}'),
            _ => false,
        });
        assert!(
            !bom_in_text,
            "BOM should not appear in any Text event content"
        );
    }

    #[cfg(feature = "html")]
    #[test]
    fn any_reader_from_reader_matches_from_str_html() {
        use std::io::Cursor;

        let input = "<p>hello</p>";
        let mut r1 = AnyReader::from_str(InputFormat::Html, input).unwrap();
        let mut r2 =
            AnyReader::from_reader(InputFormat::Html, Cursor::new(input.as_bytes())).unwrap();
        let events1: Vec<_> = core::iter::from_fn(|| r1.next_event().unwrap()).collect();
        let events2: Vec<_> = core::iter::from_fn(|| r2.next_event().unwrap()).collect();
        assert_eq!(events1, events2);
    }
}