rotext_utils 0.2.0

Utilities around the official Rotext 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
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

use std::mem::MaybeUninit;

use rotext_core::{Error, Stack};

pub struct VecStack<T> {
    items: Vec<T>,
}
impl<T> Stack<T> for VecStack<T> {
    fn new() -> Self {
        Self { items: vec![] }
    }

    fn try_push(&mut self, item: T) -> Result<(), Error> {
        self.items.push(item);
        Ok(())
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn as_slice(&self) -> &[T] {
        &self.items
    }
}

pub struct ArrayStack<T, const N: usize> {
    items: [T; N],
    len: usize,
}
impl<T, const N: usize> Stack<T> for ArrayStack<T, N> {
    fn new() -> Self {
        Self {
            items: unsafe {
                #[allow(clippy::uninit_assumed_init)]
                MaybeUninit::uninit().assume_init()
            },
            len: 0,
        }
    }

    fn try_push(&mut self, item: T) -> Result<(), Error> {
        if self.len == N {
            Err(Error::OutOfStackSpace)
        } else {
            self.items[self.len] = item;
            self.len += 1;
            Ok(())
        }
    }

    fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            None
        } else {
            self.len -= 1;
            Some(std::mem::replace(&mut self.items[self.len], unsafe {
                #[allow(clippy::uninit_assumed_init)]
                MaybeUninit::uninit().assume_init()
            }))
        }
    }

    fn as_slice(&self) -> &[T] {
        &self.items[0..self.len]
    }
}

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

    use rotext_core::EventType;
    use rotext_internal_test::{
        suites::block::support::{
            assert_parse_error_with_stack, assert_parse_ok_and_output_matches_with_stack,
        },
        BlockContext,
    };

    #[test]
    fn array_stack_works() {
        let mut s = ArrayStack::<usize, 2>::new();
        assert!(s.pop().is_none());
        assert!(s.try_push(1).is_ok());
        assert!(s.try_push(2).is_ok());
        assert!(s.try_push(3).is_err());
        assert_eq!(s.pop(), Some(2));
        assert_eq!(s.pop(), Some(1));
        assert!(s.try_push(4).is_ok());
    }

    #[test]
    fn array_stack_works_with_block_parser() {
        let ctx: BlockContext<ArrayStack<_, 2>> = BlockContext::new();

        assert_parse_ok_and_output_matches_with_stack(&ctx, "", &vec![]);
        assert_parse_ok_and_output_matches_with_stack(
            &ctx,
            ">",
            &vec![
                (EventType::EnterBlockQuote, None),
                (EventType::ExitBlock, None),
            ],
        );
        assert_parse_ok_and_output_matches_with_stack(
            &ctx,
            "> >",
            &vec![
                (EventType::EnterBlockQuote, None),
                (EventType::EnterBlockQuote, None),
                (EventType::ExitBlock, None),
                (EventType::ExitBlock, None),
            ],
        );
        assert_parse_ok_and_output_matches_with_stack(
            &ctx,
            "> > foo",
            &vec![
                (EventType::EnterBlockQuote, None),
                (EventType::EnterBlockQuote, None),
                (EventType::EnterParagraph, None),
                (EventType::__Unparsed, Some("foo")),
                (EventType::ExitBlock, None),
                (EventType::ExitBlock, None),
                (EventType::ExitBlock, None),
            ],
        );
        assert_parse_error_with_stack(&ctx, "> > >", Error::OutOfStackSpace)
    }
}