udled 0.7.0

Tokenizer and 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

use udled::{prelude::*, Char, Input, Span};

#[test]
fn parse_char_and_string() {
    let mut input = Input::new("abc");

    // parse a single char
    let a = input.parse(Char).expect("expected char");
    assert_eq!(a.value, 'a');
    assert_eq!(a.span, Span::new(0, 1));

    // parse a string literal from the remaining input
    let s = input.parse("bc").expect("expected string");
    assert_eq!(s.value, "bc");
    assert_eq!(s.span, Span::new(1, 3));
}

#[test]
fn many_into_integer() {
    use udled::tokenizers::Digit;

    let mut input = Input::new("1234");

    // parse exactly four digits as a tuple and convert into an integer
    let tok = (
        Digit::default(),
        Digit::default(),
        Digit::default(),
        Digit::default(),
    )
        .into_integer(10);

    let item = input.parse(tok).expect("expected integer");

    assert_eq!(item.value, 1234i128);
    assert_eq!(item.span, Span::new(0, 4));
}

#[test]
fn optional_tokenizer() {
    let mut input = Input::new("");

    // optional should succeed and return None on empty input
    let none = input.parse(Char.optional()).expect("optional failed");
    assert!(none.is_none());

    let mut input = Input::new("z");
    let some = input
        .parse(Char.optional())
        .expect("optional failed")
        .unwrap();
    assert_eq!(some.value, 'z');
}

#[test]
fn punctuated_parse() {
    use udled::tokenizers::Digit;

    let mut input = Input::new("1,2,3");
    let punct = ',';
    let tok: udled::tokenizers::Punctuated<udled::tokenizers::Digit, char> =
        udled::tokenizers::Punctuated::new(Digit::default(), punct);
    let list = input.parse(tok).expect("punctuated failed");

    // collect only the numeric items
    let items: Vec<u32> = list.into_items().map(|it| it.value).collect();
    assert_eq!(items, vec![1, 2, 3]);
}

#[test]
fn slice_combinator() {
    let mut input = Input::new("hello");
    let item = input.parse("hell".slice()).expect("slice failed");
    assert_eq!(item.value, "hell");
    assert_eq!(item.span, Span::new(0, 4));
}