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

use std::fmt::Debug;

use serde::Deserialize;

use clauser::de::from_str;
use clauser::error::{Error, ErrorType};

#[derive(Deserialize, Debug, PartialEq)]
pub struct SingleContainer<T: Debug + PartialEq> {
    pub val: T,
}

impl<'a, T: Debug + PartialEq> SingleContainer<T>
where
    T: Deserialize<'a>,
{
    pub fn new(val: T) -> SingleContainer<T> {
        SingleContainer { val }
    }

    pub fn expect(text: &'a str, expected: T) -> Result<(), Error> {
        assert_eq!(from_str::<SingleContainer<T>>(text)?.val, expected);
        Ok(())
    }
}

pub fn expect_str<'a, T: Debug + PartialEq>(text: &'a str, expected: T) -> Result<(), Error>
where
    T: Deserialize<'a>,
{
    assert_eq!(from_str::<T>(text)?, expected);
    Ok(())
}

pub fn expect_error<T: for<'a> Deserialize<'a> + std::fmt::Debug>(
    source: &str,
    expected_error: ErrorType,
) -> Result<(), Error> {
    let result = from_str::<T>(source);
    assert!(
        result.is_err(),
        "expected error {:?} but got result {:?}",
        expected_error,
        result.unwrap()
    );
    match result {
        Ok(_) => Ok(()),
        Err(e) => match e.error_type == expected_error {
            true => Ok(()),
            false => Err(e),
        },
    }
}