splitter 0.2.5

A string and slice splitter library
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


fn main() {
    slice::run();
    string::run();
}

mod slice {
    use splitter::{Splitter, Info};

    pub fn run() {
        fn is_number(ts: &[u8]) -> bool {
            ts == b"15"
        }

        //
        // A enum with the 'Info'-derive can't have variants with fields
        // 
        // Every enum-variant needs a #[splitter(...)] attribute
        //
        // The attribute must contain a &[T] pattern (similar to match)
        //
        // The pattern can consist of a '|' seperated list of &[T], a variable name, or '_',
        // followed by a optional if statement
        //
        // The Info will use the first match, so ordering is important
        //

        #[derive(Debug, PartialEq, Info)]
        #[splitter(u8)]
        enum SliceEnum {
            #[splitter(b" " | b"\n")]
            WS,

            #[splitter(b":)")]
            Smiley,

            #[splitter(s if is_number(s))]
            Number,

            #[splitter(_)]
            Other,
        }

        let sp = Splitter::new(
            b"hello\nsplitter :) 15",
            [" ", "\n"],
        ).with_info::<SliceEnum>();

        assert_eq!(
            sp.collect::<Vec<_>>(),
            vec![
                SliceEnum::Other,
                SliceEnum::WS,
                SliceEnum::Other,
                SliceEnum::WS,
                SliceEnum::Smiley,
                SliceEnum::WS,
                SliceEnum::Number,
            ],
        );
    }
}

mod string {
    use splitter::{StrSplitter, StrInfo};

    pub fn run() {
        fn is_number(s: &str) -> bool {
            // can do some regex here if you want
            s.chars().all(char::is_numeric)
        }

        //
        // A enum with the 'StrInfo'-derive can't have variants with fields
        // 
        // Every enum-variant needs a #[splitter(...)] attribute
        //
        // The attribute must contain a &str pattern (similar to match)
        //
        // The pattern can consist of a '|' seperated list of &str, a variable name, or '_',
        // followed by a optional if statement
        //
        // The StrInfo will use the first match, so ordering is important
        //

        #[derive(Debug, PartialEq, StrInfo)]
        enum StrEnum {
            #[splitter(" " | "\n")]
            WS,

            #[splitter(":)")]
            Smiley,

            #[splitter(s if is_number(s))]
            Number,

            #[splitter(_)]
            Other,
        }

        let sp = StrSplitter::new(
            "hello\nsplitter :) 15",
            [" ", "\n"],
        ).with_info::<StrEnum>();

        assert_eq!(
            sp.collect::<Vec<_>>(),
            vec![
                StrEnum::Other,
                StrEnum::WS,
                StrEnum::Other,
                StrEnum::WS,
                StrEnum::Smiley,
                StrEnum::WS,
                StrEnum::Number,
            ],
        );
    }
}