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

//!	# Percent encode fields.
//!
//!	This is a helper module for using serde_drive. It allows you to specify that
//!	some fields in your type will be automatically percent-encoded on
//!	serialization and percent-decoded on deserialization.
//!
//!	## Example
//!
//!	```
//!	use serde_derive::{Deserialize, Serialize};
//!
//!	#[derive(Debug, Deserialize, Serialize, PartialEq)]
//!	struct Item {
//!		#[serde(with="serde_urlencoded_field::path_segment")]
//!		id: String,
//!		mime: String,
//!	}
//!
//!	let item = Item {
//!		id: "my/item".to_string(),
//!		mime: "application/wasm".to_string(),
//!	};
//!
//!	let json = serde_json::to_string(&item).unwrap();
//!	assert_eq!(json, r#"{"id":"my%2Fitem","mime":"application/wasm"}"#);
//!
//!	let item2: Item = serde_json::from_str(&json).unwrap();
//!	assert_eq!(item2, item);
//!	```
//!
//!	## Types
//!
//!	serde_urlencoded_field can serialize anything that implements `AsRef<[u8]>`,
//!	including `String`, `&str`, `Vec<u8>` and `&[u8]`.
//!
//!	serde_urlencoded_field can deserialize into `String` and `Vec<u8>`. Other
//!	types can be added by implementing the FromPercentDecode trait.

#[cfg(test)]mod test;

struct Visitor<T>(std::marker::PhantomData<T>);

impl<T> Visitor<T> {
	fn new() -> Self {
		Visitor(std::marker::PhantomData)
	}
}

impl<'a, T: FromPercentDecode> serde::de::Visitor<'a> for Visitor<T> {
	type Value = T;

	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
		write!(formatter, "a sequence of bytes")
	}

	fn visit_borrowed_str<E: serde::de::Error>(self, v: &'a str) -> Result<Self::Value, E> {
		let decoded = percent_encoding::percent_decode(v.as_bytes());
		FromPercentDecode::from(decoded)
	}
}

pub trait FromPercentDecode: Sized {
	fn from<E: serde::de::Error>(pd: percent_encoding::PercentDecode) -> Result<Self, E>;
}

impl FromPercentDecode for Vec<u8> {
	fn from<E: serde::de::Error>(pd: percent_encoding::PercentDecode) -> Result<Self, E> {
		Ok(pd.collect())
	}
}

impl FromPercentDecode for String {
	fn from<E: serde::de::Error>(pd: percent_encoding::PercentDecode) ->  Result<Self, E> {
		pd.decode_utf8()
			.map(|cow| cow.into_owned())
			.map_err(E::custom)
	}
}

fn deserialize<'d, T: FromPercentDecode, D: serde::Deserializer<'d>>(
	de: D,
) -> Result<T, D::Error> {
	de.deserialize_str(Visitor::new())
}

fn serialize<S: serde::Serializer>(
	data: impl AsRef<[u8]>,
	ser: S,
	encoding_set: &'static percent_encoding::AsciiSet,
) -> Result<S::Ok, S::Error> {
	let encoded = percent_encoding::percent_encode(data.as_ref(), encoding_set)
		.collect::<String>();
	ser.serialize_str(&encoded)
}

macro_rules! version {
	($name:ident, $set:path) => {
		pub mod $name {
			pub fn deserialize<'d, T: crate::FromPercentDecode, D: serde::Deserializer<'d>>(
				de: D,
			) -> Result<T, D::Error> {
				crate::deserialize(de)
			}

			pub fn serialize<S: serde::Serializer>(
				data: impl AsRef<[u8]>,
				ser: S,
			) -> Result<S::Ok, S::Error> {
				crate::serialize(data, ser, &$set)
			}
		}
	}
}

const QUERY_ENCODE_SET: percent_encoding::AsciiSet = percent_encoding::CONTROLS.add(b' ').add(b'"').add(b'#').add(b'<').add(b'>');
const DEFAULT_ENCODE_SET: percent_encoding::AsciiSet = QUERY_ENCODE_SET.add(b'`').add(b'?').add(b'{').add(b'}');
const PATH_SEGMENT_ENCODE_SET: percent_encoding::AsciiSet = DEFAULT_ENCODE_SET.add(b'%').add(b'/');
const USERINFO_ENCODE_SET: percent_encoding::AsciiSet = DEFAULT_ENCODE_SET.add(b'/').add(b':').add(b';').add(b'=').add(b'@').add(b'[').add(b'\\').add(b']').add(b'^').add(b'|');

version!(default, crate::DEFAULT_ENCODE_SET);
version!(path_segment, crate::PATH_SEGMENT_ENCODE_SET);
version!(query, crate::QUERY_ENCODE_SET);
version!(simple, percent_encoding::CONTROLS);
version!(userinfo, crate::USERINFO_ENCODE_SET);