hledger_parser/directive/include/
format.rs

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
use chumsky::prelude::*;

use crate::state::State;

#[derive(Clone, Debug, PartialEq)]
pub enum Format {
    Journal,
    Timeclock,
    Timedot,
    Csv,
    Ssv,
    Tsv,
    Rules,
}

pub fn format<'a>() -> impl Parser<'a, &'a str, Format, extra::Full<Rich<'a, char>, State, ()>> {
    let journal = just("journal").map(|_| Format::Journal);
    let timeclock = just("timeclock").map(|_| Format::Timeclock);
    let timedot = just("timedot").map(|_| Format::Timedot);
    let comma_sv = just("csv").map(|_| Format::Csv);
    let semicolon_sv = just("ssv").map(|_| Format::Ssv);
    let tab_sv = just("tsv").map(|_| Format::Tsv);
    let rules = just("rules").map(|_| Format::Rules);
    journal
        .or(timeclock)
        .or(timedot)
        .or(comma_sv)
        .or(semicolon_sv)
        .or(tab_sv)
        .or(rules)
}

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

    #[test]
    fn ok_journal() {
        let result = format().then_ignore(end()).parse("journal").into_result();
        assert_eq!(result, Ok(Format::Journal));
    }

    #[test]
    fn ok_timeclock() {
        let result = format().then_ignore(end()).parse("timeclock").into_result();
        assert_eq!(result, Ok(Format::Timeclock));
    }

    #[test]
    fn ok_timedot() {
        let result = format().then_ignore(end()).parse("timedot").into_result();
        assert_eq!(result, Ok(Format::Timedot));
    }

    #[test]
    fn ok_csv() {
        let result = format().then_ignore(end()).parse("csv").into_result();
        assert_eq!(result, Ok(Format::Csv));
    }

    #[test]
    fn ok_ssv() {
        let result = format().then_ignore(end()).parse("ssv").into_result();
        assert_eq!(result, Ok(Format::Ssv));
    }

    #[test]
    fn ok_tsv() {
        let result = format().then_ignore(end()).parse("tsv").into_result();
        assert_eq!(result, Ok(Format::Tsv));
    }

    #[test]
    fn ok_rules() {
        let result = format().then_ignore(end()).parse("rules").into_result();
        assert_eq!(result, Ok(Format::Rules));
    }

    #[test]
    fn err() {
        let result = format().then_ignore(end()).parse("err").into_result();
        assert!(result.is_err());
    }
}