simple_config 0.134.0

A config language for humans that is not self-describing.
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

#[derive(Debug,PartialEq,serde::Deserialize)]
enum Custom {
	Unit,
	NewType(bool),
	Tuple(u8, u16),
	Struct{s: String, f: f32},
}

#[test]
fn test() {
	#[derive(Debug,PartialEq,serde::Deserialize)]
	struct Test {
		result_ok: Result<String, u32>,
		result_err: Result<String, u32>,
		custom_unit_inline: Custom,
		custom_unit_newline: Custom,
		custom_newtype: Custom,
		custom_tuple: Custom,
		custom_struct: Custom,
	}

	let t: Test = crate::from_bytes(b"
		result_ok:
			Ok: # foo
				whatever
		result_err:
			Err: 10 # foo

		custom_unit_inline: Unit
		custom_unit_newline: # bar
			Unit # unit
		custom_newtype: # foo

			NewType: true
		custom_tuple:
		# bar
			Tuple:


				1 # bar

				8
		custom_struct:
			Struct: # bar
				# bar
				s: foo
				# bar
				f: 3.14
	").unwrap();
	assert_eq!(t, Test{
		result_ok: Ok("whatever".into()),
		result_err: Err(10),

		custom_unit_inline: Custom::Unit,
		custom_unit_newline: Custom::Unit,
		custom_newtype: Custom::NewType(true),
		custom_tuple: Custom::Tuple(1, 8),
		custom_struct: Custom::Struct{s: "foo".into(), f: 3.14},
	});
}

#[test]
fn key() {
	#[derive(Debug,Eq,PartialEq,Ord,PartialOrd,serde::Deserialize)]
	enum E { Foo, Bar, Baz, Valued(bool) }

	let t: std::collections::BTreeMap<E, bool> = crate::from_bytes(b"
		Foo: true
		Bar: false
	").unwrap();
	assert_eq!(t, [
		(E::Foo, true),
		(E::Bar, false),
	].into_iter().collect());
}