clauser 0.1.0

Library for parsing and deserializing Clausewitz 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

use super::util::{expect_error, SingleContainer};
use clauser::error::{Error, ErrorType};
use clauser_macros::duplicate_keys;
use trybuild::TestCases;

#[derive(Debug, PartialEq)]
#[duplicate_keys]
struct DuplicateKeys {
    #[from_duplicate_key]
    item: Vec<String>,
}

#[test]
pub fn duplicate_keys() -> Result<(), Error> {
    SingleContainer::<DuplicateKeys>::expect(
        "val = { item = one item = two item = three }",
        DuplicateKeys {
            item: vec!["one", "two", "three"]
                .iter()
                .map(|s| String::from(*s))
                .collect(),
        },
    )?;
    SingleContainer::<DuplicateKeys>::expect(
        "val = { item = one }",
        DuplicateKeys {
            item: vec![String::from("one")],
        },
    )?;

    Ok(())
}

#[derive(Debug, PartialEq)]
#[duplicate_keys]
struct DuplicateAndNormalKeys {
    #[from_duplicate_key]
    item: Vec<String>,
    unique1: i32,
    unique2: String,
}

#[test]
pub fn duplicate_and_normal_keys() -> Result<(), Error> {
    let source = "
	val = { 
		item = one 
		unique1 = 50 
		item = two 
		item = three 
		unique2 = cool 
	}";
    SingleContainer::<DuplicateAndNormalKeys>::expect(
        source,
        DuplicateAndNormalKeys {
            item: vec!["one", "two", "three"]
                .iter()
                .map(|s| String::from(*s))
                .collect(),
            unique1: 50,
            unique2: String::from("cool"),
        },
    )?;

    Ok(())
}

#[test]
pub fn empty_duplicate() -> Result<(), Error> {
    SingleContainer::<DuplicateAndNormalKeys>::expect(
        "val = { unique1 = 0 unique2 = test }",
        DuplicateAndNormalKeys {
            item: vec![],
            unique1: 0,
            unique2: String::from("test"),
        },
    )?;

    SingleContainer::<DuplicateKeys>::expect("val = { }", DuplicateKeys { item: vec![] })?;

    Ok(())
}

#[test]
pub fn duplicate_keys_invalid() -> Result<(), Error> {
    expect_error::<SingleContainer<i32>>("val = 1 val = 2 val = 3", ErrorType::DuplicateField)?;

    Ok(())
}

#[test]
pub fn only_named_structs() {
    let t = TestCases::new();
    t.compile_fail("tests/deserializer/cases/00_enum.rs");
    t.compile_fail("tests/deserializer/cases/01_union.rs");
    t.compile_fail("tests/deserializer/cases/02_named.rs");
}

#[test]
pub fn correct_field_type() {
    let t = TestCases::new();
    t.compile_fail("tests/deserializer/cases/03_wrong_type.rs");
    t.compile_fail("tests/deserializer/cases/04_not_vec.rs");
}