chuchi 0.1.5

Http async library based on hyper and tokio
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::{
	collections::{HashMap, HashSet},
	str::FromStr,
};

use byte_parser::{ParseIterator, StrParser};
use matchit::Params;

#[derive(Debug, Clone)]
pub struct PathParams {
	inner: HashMap<String, String>,
}

impl PathParams {
	pub(crate) fn new(params: Params) -> Self {
		let mut inner = HashMap::new();

		for (key, value) in params.iter() {
			inner.insert(key.to_string(), value.to_string());
		}

		Self { inner }
	}

	pub fn exists(&self, key: impl AsRef<str>) -> bool {
		self.inner.contains_key(key.as_ref())
	}

	/// ## Note
	/// Due to the fact that {*?rest} exists, a key which does not exist
	/// will be treated as an empty string
	pub fn parse<T>(&self, key: impl AsRef<str>) -> Result<T, T::Err>
	where
		T: FromStr,
	{
		self.inner
			.get(key.as_ref())
			.map(AsRef::as_ref)
			.unwrap_or("")
			.parse()
	}

	/// ## Note
	/// Due to the fact that {*?rest} exists the rest might not always
	/// be set, so none might be returned even if ParamsNames says it exists
	pub fn get(&self, key: impl AsRef<str>) -> Option<&str> {
		self.inner.get(key.as_ref()).map(|s| s.as_str())
	}
}

/* pub struct Parser {
	pub path: &'a str
} */

// we need to parse {}
// and allow it to be escaped with {{ or }}

#[derive(Debug, Clone)]
pub struct ParamsNames<'a> {
	list: HashSet<&'a str>,
}

impl<'a> ParamsNames<'a> {
	pub fn parse(s: &'a str) -> Self {
		let mut parser = StrParser::new(s);

		let mut list = HashSet::new();

		#[allow(clippy::never_loop)]
		'template_loop: loop {
			parser.consume_while_byte_fn(|&b| b != b'{');
			// either we're at the end or we found a {
			// we need to check for escapes
			let Some(b) = parser.next() else {
				return Self { list };
			};
			debug_assert_eq!(b, b'{');

			// handle escapes
			if parser.next_if(|&b| b == b'{').is_some() {
				continue 'template_loop;
			}

			let mut parser = parser.record();

			loop {
				parser.consume_while_byte_fn(|&b| b != b'}' && b != b'{');
				match parser.peek() {
					Some(b'{') => {
						panic!("unexpected {{");
					}
					Some(b'}') => {
						assert!(
							!matches!(parser.peek_at(2), Some(b) if b == b'}'),
							"escapping does not work in template string"
						);

						let s = parser
							.to_str()
							// trim `{*?name}` name trimming this at once makes sure * is not
							// where it doesn't work
							.trim_start_matches("*?")
							// trim `{*name}`
							.trim_start_matches('*');
						list.insert(s);

						parser.next().unwrap();

						continue 'template_loop;
					}
					Some(b) => unreachable!("reached byte {b}"),
					None => {
						panic!("unexpected end of string");
					}
				}
			}
		}
	}

	pub fn exists(&self, key: impl AsRef<str>) -> bool {
		self.list.contains(key.as_ref())
	}

	pub fn is_empty(&self) -> bool {
		self.list.is_empty()
	}
}