yarpl 0.0.23

Yet Another Rust Parsing Library
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


#[allow(deprecated)]
#[allow(const_item_mutation)]
#[allow(unused_must_use)]
#[cfg(test)]


#[cfg(test)]
mod tests {

	use yarpl::*;

	type Letters = Many<Either<"abcdefghijklmnopqrstuvwxyz">>;
	type Digits = Many<Either<"0123456789">>;

	#[test]
	fn parse_letters() {

		let ref mut parser = Parser::from("asdf");

		assert!(parser.parse::<Letters>().is_ok());

	}

	#[test]
	fn parse_digits() {

		let ref mut parser = Parser::from("1234asdf");

		assert!(parser.parse::<Digits>().is_ok());
	}


	#[test]
	fn parse_literal() {
		
		type AAAA = Literal<"aaaa">;

		let ref mut parser = Parser::from("asdf    \naaaa");

		parser.disable_strict_mode();

		let result = parser.parse::<Literal<"safaffsda">>();
		let _ = parser.parse::<AAAA>();


		if result.is_err() {

			println!("{}", result.unwrap_err())

		}

	}

	#[test]
	fn parse_maybe() {
		
		let ref mut parser = Parser::from("asdf");
		let ref mut other_parser = parser.clone();

		assert!(parser.parse::<Maybe::<Literal<"asdf">>>().is_ok());
		assert!(other_parser.parse::<Maybe::<Literal<"yeah">>>().is_ok());

	}


	#[test]
	fn parse_type_alias() {
		
		type Newline = Literal::<"\n">;
		
		assert!(Parser::from("\n").parse::<Newline>().is_ok());
		
	}
	
	#[test]
	fn parse_either() {
		
		type Yeah = Either<"0123456789">;
		
		let ref mut parser = Parser::from("823813");
	
		assert!(parser.parse::<Yeah>().is_ok());
		
	} 
	
	
}