okane-core 0.19.0

Library to support parsing, emitting and processing Ledger (https://www.ledger-cli.org/) format files.
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

//! Defines parser functions related to character input.

use winnow::{
    Parser,
    ascii::line_ending,
    combinator::{alt, delimited, eof, trace},
    error::ParserError,
    stream::{AsChar, Compare, Stream, StreamIsPartial},
    token::{one_of, take_till, take_while},
};

/// Semicolon or line ending.
pub fn line_ending_or_semi<I, E>(input: &mut I) -> winnow::Result<<I as Stream>::Slice, E>
where
    I: StreamIsPartial + Stream,
    I: Compare<&'static str>,
    <I as Stream>::Token: AsChar + Clone,
    E: ParserError<I>,
{
    trace("character::line_ending_or_semi", alt((line_ending, ";"))).parse_next(input)
}

/// Parses non-zero string until line_ending or comma appears.
pub fn till_line_ending_or_semi<I, E>(input: &mut I) -> winnow::Result<<I as Stream>::Slice, E>
where
    I: Stream + StreamIsPartial,
    E: ParserError<I>,
    <I as Stream>::Token: AsChar,
{
    trace(
        "character::till_line_ending_or_semi",
        take_till(1.., [';', '\r', '\n']),
    )
    .parse_next(input)
}

/// Line ending or EOF.
pub fn line_ending_or_eof<I, E>(input: &mut I) -> winnow::Result<(), E>
where
    I: Stream + StreamIsPartial + winnow::stream::Compare<&'static str>,
    <I as Stream>::Token: AsChar,
    E: ParserError<I>,
{
    trace("character::line_ending_or_eof", alt((line_ending, eof)))
        .void()
        .parse_next(input)
}

/// Consume all newlines.
pub fn newlines<I, E>(input: &mut I) -> winnow::Result<<I as Stream>::Slice, E>
where
    I: Stream + StreamIsPartial + winnow::stream::Compare<&'static str>,
    <I as Stream>::Token: AsChar,
    E: ParserError<I>,
{
    trace("character::newlines", take_while(0.., b"\r\n")).parse_next(input)
}

/// Parses unnested string in paren.
pub fn paren_str<I, E>(input: &mut I) -> winnow::Result<<I as Stream>::Slice, E>
where
    I: Stream + StreamIsPartial,
    E: ParserError<I>,
    <I as Stream>::Token: AsChar + Clone,
{
    paren(take_till(0.., ')')).parse_next(input)
}

/// Parses given parser within the paren.
pub fn paren<I, O, E: ParserError<I>, F>(inner: F) -> impl Parser<I, O, E>
where
    F: Parser<I, O, E>,
    I: winnow::stream::Stream + StreamIsPartial,
    <I as winnow::stream::Stream>::Token: winnow::stream::AsChar + Clone,
{
    trace(
        "character::paren",
        delimited(one_of('('), inner, one_of(')')),
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse::testing::expect_parse_ok;

    use pretty_assertions::assert_eq;
    use winnow::token::take_while;

    #[test]
    fn line_ending_or_semi_accepts_valid_input() {
        assert_eq!(
            expect_parse_ok(line_ending_or_semi, ";remain"),
            ("remain", ";")
        );
        assert_eq!(
            expect_parse_ok(line_ending_or_semi, "\n;remain"),
            (";remain", "\n")
        );
        assert_eq!(
            expect_parse_ok(line_ending_or_semi, "\r\n;remain"),
            (";remain", "\r\n")
        );
    }

    #[test]
    fn paren_str_valid() {
        assert_eq!(
            expect_parse_ok(paren_str, "(this is a pen)"),
            ("", "this is a pen")
        )
    }

    #[test]
    fn paren_valid() {
        assert_eq!(
            expect_parse_ok(paren(paren(take_while(1.., 'a'..='c'))), "((abcbca))"),
            ("", "abcbca")
        )
    }
}