chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Replace ruma_common::serde::urlencoded with serde_html_form

Browse Source
This commit is contained in:
Jonas Platte 2023-01-02 17:47:33 +01:00
parent 5912d8ebdd
commit ff8ab6b085
No known key found for this signature in database
GPG Key ID: AAA7A61F696C3E0C
25 changed files with 30 additions and 2198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -13,6 +13,7 @@ http = "0.2.8"
js_int = "0.2.2"
maplit = "1.0.2"
serde = { version = "1.0.147", features = ["derive"] }
serde_html_form = "0.2.0"
serde_json = "1.0.87"
thiserror = "1.0.37"
tracing = { version = "0.1.37", default-features = false, features = ["std"] }

1
crates/ruma-client-api/Cargo.toml
View File

@ -40,6 +40,7 @@ maplit = { workspace = true }
percent-encoding = "2.1.0"
ruma-common = { version = "0.10.5", path = "../ruma-common", features = ["api", "events"] }
serde = { workspace = true }
serde_html_form = { workspace = true }
serde_json = { workspace = true }
[dev-dependencies]

9
crates/ruma-client-api/src/push/set_pushrule.rs
View File

@ -78,10 +78,11 @@ pub mod v3 {
considering_versions: &[ruma_common::api::MatrixVersion],
) -> Result<http::Request<T>, ruma_common::api::error::IntoHttpError> {
use http::header;
use ruma_common::serde::urlencoded;
let query_string =
urlencoded::to_string(RequestQuery { before: self.before, after: self.after })?;
let query_string = serde_html_form::to_string(RequestQuery {
before: self.before,
after: self.after,
})?;
let url = METADATA.make_endpoint_url(
considering_versions,
@ -155,7 +156,7 @@ pub mod v3 {
))?;
let IncomingRequestQuery { before, after } =
ruma_common::serde::urlencoded::from_str(request.uri().query().unwrap_or(""))?;
serde_html_form::from_str(request.uri().query().unwrap_or(""))?;
let rule = match kind {
RuleKind::Override => {

7
crates/ruma-client-api/src/state/send_state_event.rs
View File

@ -121,9 +121,8 @@ pub mod v3 {
) -> Result<http::Request<T>, ruma_common::api::error::IntoHttpError> {
use http::header::{self, HeaderValue};
let query_string = ruma_common::serde::urlencoded::to_string(RequestQuery {
timestamp: self.timestamp,
})?;
let query_string =
serde_html_form::to_string(RequestQuery { timestamp: self.timestamp })?;
let http_request = http::Request::builder()
.method(http::Method::PUT)
@ -187,7 +186,7 @@ pub mod v3 {
};
let request_query: RequestQuery =
ruma_common::serde::urlencoded::from_str(request.uri().query().unwrap_or(""))?;
serde_html_form::from_str(request.uri().query().unwrap_or(""))?;
let body = serde_json::from_slice(request.body().as_ref())?;

1
crates/ruma-client/Cargo.toml
View File

@ -47,6 +47,7 @@ reqwest = { version = "0.11.4", optional = true, default-features = false }
ruma-client-api = { version = "0.15.3", path = "../ruma-client-api", optional = true, features = ["client"] }
ruma-common = { version = "0.10.5", path = "../ruma-common", features = ["api"] }
serde = { workspace = true }
serde_html_form = { workspace = true }
serde_json = { workspace = true }
tracing = { version = "0.1.30", default-features = false, features = ["std"] }

3
crates/ruma-client/src/lib.rs
View File

@ -183,10 +183,9 @@ fn add_user_id_to_query<C: HttpClient + ?Sized, R: OutgoingRequest>(
) -> impl FnOnce(&mut http::Request<C::RequestBody>) -> Result<(), ResponseError<C, R>> + '_ {
use assign::assign;
use http::uri::Uri;
use ruma_common::serde::urlencoded;
move |http_request| {
let extra_params = urlencoded::to_string([("user_id", user_id)]).unwrap();
let extra_params = serde_html_form::to_string([("user_id", user_id)]).unwrap();
let uri = http_request.uri_mut();
let new_path_and_query = match uri.query() {
Some(params) => format!("{}?{params}&{extra_params}", uri.path()),

2
crates/ruma-common/CHANGELOG.md
View File

@ -43,6 +43,8 @@ Breaking changes:
now removed)
* Move the `Unsigned` associated type from `StateEventContent` to `OriginalStateEventContent`
* `Redacted*EventContent`s don't have an `unsigned` type anymore
* Remove the `serde::urlencoded` module
* Query string (de)serialization is now done by the `serde_html_form` crate
Improvements:

1
crates/ruma-common/Cargo.toml
View File

@ -67,6 +67,7 @@ regex = { version = "1.5.6", default-features = false, features = ["std", "perf"
ruma-identifiers-validation = { version = "0.9.0", path = "../ruma-identifiers-validation", default-features = false }
ruma-macros = { version = "0.10.5", path = "../ruma-macros" }
serde = { workspace = true }
serde_html_form = { workspace = true }
serde_json = { workspace = true, features = ["raw_value"] }
thiserror = { workspace = true }
tracing = { workspace = true, features = ["attributes"] }

2
crates/ruma-common/src/api.rs
View File

@ -335,7 +335,7 @@ pub trait OutgoingRequestAppserviceExt: OutgoingRequest {
) -> Result<http::Request<T>, IntoHttpError> {
let mut http_request =
self.try_into_http_request(base_url, access_token, considering_versions)?;
let user_id_query = crate::serde::urlencoded::to_string([("user_id", user_id)])?;
let user_id_query = serde_html_form::to_string([("user_id", user_id)])?;
let uri = http_request.uri().to_owned();
let mut parts = uri.into_parts();

4
crates/ruma-common/src/api/error.rs
View File

@ -123,7 +123,7 @@ pub enum IntoHttpError {
/// Query parameter serialization failed.
#[error("query parameter serialization failed: {0}")]
Query(#[from] crate::serde::urlencoded::ser::Error),
Query(#[from] serde_html_form::ser::Error),
/// Header serialization failed.
#[error("header serialization failed: {0}")]
@ -228,7 +228,7 @@ pub enum DeserializationError {
/// Query parameter deserialization failed.
#[error(transparent)]
Query(#[from] crate::serde::urlencoded::de::Error),
Query(#[from] serde_html_form::de::Error),
/// Got an invalid identifier.
#[error(transparent)]

1
crates/ruma-common/src/lib.rs
View File

@ -69,5 +69,6 @@ pub mod exports {
pub use http;
pub use ruma_macros;
pub use serde;
pub use serde_html_form;
pub use serde_json;
}

1
crates/ruma-common/src/serde.rs
View File

@ -18,7 +18,6 @@ mod raw;
pub mod single_element_seq;
mod strings;
pub mod test;
pub mod urlencoded;
pub use self::{
base64::{Base64, Base64DecodeError},

9
crates/ruma-common/src/serde/urlencoded.rs
View File

@ -1,9 +0,0 @@
//! `x-www-form-urlencoded` meets Serde
pub mod de;
pub mod ser;
#[doc(inline)]
pub use de::{from_bytes, from_reader, from_str, Deserializer};
#[doc(inline)]
pub use ser::{to_string, Serializer};

358
crates/ruma-common/src/serde/urlencoded/de.rs
View File

@ -1,358 +0,0 @@
//! Deserialization support for the `application/x-www-form-urlencoded` format.
use std::{
borrow::Cow,
collections::btree_map::{self, BTreeMap},
io::Read,
};
use form_urlencoded::{parse, Parse as UrlEncodedParse};
use serde::{
de::{self, value::MapDeserializer, Error as de_Error, IntoDeserializer},
forward_to_deserialize_any,
};
#[doc(inline)]
pub use serde::de::value::Error;
mod val_or_vec;
use val_or_vec::ValOrVec;
/// Deserializes a `application/x-www-form-urlencoded` value from a `&[u8]`.
///
/// ```
/// let meal = vec![
/// ("bread".to_owned(), "baguette".to_owned()),
/// ("cheese".to_owned(), "comté".to_owned()),
/// ("fat".to_owned(), "butter".to_owned()),
/// ("meat".to_owned(), "ham".to_owned()),
/// ];
///
/// assert_eq!(
/// ruma_common::serde::urlencoded::from_bytes::<Vec<(String, String)>>(
/// b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"
/// ),
/// Ok(meal)
/// );
/// ```
pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
where
T: de::Deserialize<'de>,
{
T::deserialize(Deserializer::new(parse(input)))
}
/// Deserializes a `application/x-www-form-urlencoded` value from a `&str`.
///
/// ```
/// let meal = vec![
/// ("bread".to_owned(), "baguette".to_owned()),
/// ("cheese".to_owned(), "comté".to_owned()),
/// ("fat".to_owned(), "butter".to_owned()),
/// ("meat".to_owned(), "ham".to_owned()),
/// ];
///
/// assert_eq!(
/// ruma_common::serde::urlencoded::from_str::<Vec<(String, String)>>(
/// "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"
/// ),
/// Ok(meal)
/// );
/// ```
pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
where
T: de::Deserialize<'de>,
{
from_bytes(input.as_bytes())
}
/// Convenience function that reads all bytes from `reader` and deserializes
/// them with `from_bytes`.
pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error>
where
T: de::DeserializeOwned,
R: Read,
{
let mut buf = vec![];
reader
.read_to_end(&mut buf)
.map_err(|e| de::Error::custom(format_args!("could not read input: {e}")))?;
from_bytes(&buf)
}
/// A deserializer for the `application/x-www-form-urlencoded` format.
///
/// * Supported top-level outputs are structs, maps and sequences of pairs, with or without a given
/// length.
///
/// * Main `deserialize` methods defers to `deserialize_map`.
///
/// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size` defers to
/// `deserialize`.
pub struct Deserializer<'de> {
inner: MapDeserializer<'de, EntryIterator<'de>, Error>,
}
impl<'de> Deserializer<'de> {
/// Returns a new `Deserializer`.
pub fn new(parse: UrlEncodedParse<'de>) -> Self {
Deserializer { inner: MapDeserializer::new(group_entries(parse).into_iter()) }
}
}
impl<'de> de::Deserializer<'de> for Deserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_map(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_map(self.inner)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_seq(self.inner)
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.inner.end()?;
visitor.visit_unit()
}
forward_to_deserialize_any! {
bool
u8
u16
u32
u64
i8
i16
i32
i64
f32
f64
char
str
string
option
bytes
byte_buf
unit_struct
newtype_struct
tuple_struct
struct
identifier
tuple
enum
ignored_any
}
}
fn group_entries(parse: UrlEncodedParse<'_>) -> BTreeMap<Part<'_>, ValOrVec<Part<'_>>> {
use btree_map::Entry::*;
let mut res = BTreeMap::new();
for (key, value) in parse {
match res.entry(Part(key)) {
Vacant(v) => {
v.insert(ValOrVec::Val(Part(value)));
}
Occupied(mut o) => {
o.get_mut().push(Part(value));
}
}
}
res
}
/*
input: a=b&c=d&a=c
vvvvv
next(): a => Wrapper([b, c])
next(): c => Wrapper([d])
struct Foo {
a: Vec<String>,
c: Vec<String>,
}
struct Bar {
a: Vec<String>,
c: String,
}
struct Baz {
a: String,
}
*/
type EntryIterator<'de> = btree_map::IntoIter<Part<'de>, ValOrVec<Part<'de>>>;
#[derive(PartialEq, PartialOrd, Eq, Ord)]
struct Part<'de>(Cow<'de, str>);
impl<'de> IntoDeserializer<'de> for Part<'de> {
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
macro_rules! forward_parsed_value {
($($ty:ident => $method:ident,)*) => {
$(
fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
{
match self.0.parse::<$ty>() {
Ok(val) => val.into_deserializer().$method(visitor),
Err(e) => Err(de::Error::custom(e))
}
}
)*
}
}
impl<'de> de::Deserializer<'de> for Part<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
match self.0 {
Cow::Borrowed(value) => visitor.visit_borrowed_str(value),
Cow::Owned(value) => visitor.visit_string(value),
}
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_enum(ValueEnumAccess(self.0))
}
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
forward_to_deserialize_any! {
char
str
string
unit
bytes
byte_buf
unit_struct
tuple_struct
struct
identifier
tuple
ignored_any
seq
map
}
forward_parsed_value! {
bool => deserialize_bool,
u8 => deserialize_u8,
u16 => deserialize_u16,
u32 => deserialize_u32,
u64 => deserialize_u64,
i8 => deserialize_i8,
i16 => deserialize_i16,
i32 => deserialize_i32,
i64 => deserialize_i64,
f32 => deserialize_f32,
f64 => deserialize_f64,
}
}
struct ValueEnumAccess<'de>(Cow<'de, str>);
impl<'de> de::EnumAccess<'de> for ValueEnumAccess<'de> {
type Error = Error;
type Variant = UnitOnlyVariantAccess;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: de::DeserializeSeed<'de>,
{
let variant = seed.deserialize(self.0.into_deserializer())?;
Ok((variant, UnitOnlyVariantAccess))
}
}
struct UnitOnlyVariantAccess;
impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
type Error = Error;
fn unit_variant(self) -> Result<(), Self::Error> {
Ok(())
}
fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
where
T: de::DeserializeSeed<'de>,
{
Err(Error::custom("expected unit variant"))
}
fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
Err(Error::custom("expected unit variant"))
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
_visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
Err(Error::custom("expected unit variant"))
}
}

256
crates/ruma-common/src/serde/urlencoded/de/val_or_vec.rs
View File

@ -1,256 +0,0 @@
use std::{iter, ptr, vec};
use serde::de::{
self,
value::{Error, SeqDeserializer},
Deserializer, IntoDeserializer,
};
#[derive(Debug)]
pub enum ValOrVec<T> {
Val(T),
Vec(Vec<T>),
}
impl<T> ValOrVec<T> {
pub fn push(&mut self, new_val: T) {
match self {
// To transform a Self::Val into a Self::Vec, we take the existing
// value out via ptr::read and add it to a vector, together with the
// new value. Since setting self to `ValOrVec::Vec` normally would
// cause T's Drop implementation to run if it has one (which would
// free resources that will now be owned by the first vec element),
// we instead use ptr::write to set self to Self::Vec.
ValOrVec::Val(val) => {
let mut vec = Vec::with_capacity(2);
// Safety: since the vec is pre-allocated, push can't panic, so
// there is no opportunity for outside code to observe an
// invalid state of self.
unsafe {
let existing_val = ptr::read(val);
vec.push(existing_val);
vec.push(new_val);
ptr::write(self, ValOrVec::Vec(vec));
}
}
ValOrVec::Vec(vec) => vec.push(new_val),
}
}
fn deserialize_val<U, E, F>(self, f: F) -> Result<U, E>
where
F: FnOnce(T) -> Result<U, E>,
E: de::Error,
{
match self {
ValOrVec::Val(val) => f(val),
ValOrVec::Vec(_) => Err(de::Error::custom("unsupported value")),
}
}
}
impl<T> IntoIterator for ValOrVec<T> {
type Item = T;
type IntoIter = IntoIter<T>;
fn into_iter(self) -> Self::IntoIter {
IntoIter::new(self)
}
}
pub enum IntoIter<T> {
Val(iter::Once<T>),
Vec(vec::IntoIter<T>),
}
impl<T> IntoIter<T> {
fn new(vv: ValOrVec<T>) -> Self {
match vv {
ValOrVec::Val(val) => IntoIter::Val(iter::once(val)),
ValOrVec::Vec(vec) => IntoIter::Vec(vec.into_iter()),
}
}
}
impl<T> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
match self {
IntoIter::Val(iter) => iter.next(),
IntoIter::Vec(iter) => iter.next(),
}
}
}
impl<'de, T> IntoDeserializer<'de> for ValOrVec<T>
where
T: IntoDeserializer<'de> + Deserializer<'de, Error = Error>,
{
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
macro_rules! forward_to_part {
($($method:ident,)*) => {
$(
fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
{
self.deserialize_val(move |val| val.$method(visitor))
}
)*
}
}
impl<'de, T> Deserializer<'de> for ValOrVec<T>
where
T: IntoDeserializer<'de> + Deserializer<'de, Error = Error>,
{
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
match self {
ValOrVec::Val(val) => val.deserialize_any(visitor),
ValOrVec::Vec(_) => self.deserialize_seq(visitor),
}
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_seq(SeqDeserializer::new(self.into_iter()))
}
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_enum(name, variants, visitor))
}
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_tuple(len, visitor))
}
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_struct(name, fields, visitor))
}
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_unit_struct(name, visitor))
}
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_tuple_struct(name, len, visitor))
}
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
self.deserialize_val(move |val| val.deserialize_newtype_struct(name, visitor))
}
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_unit()
}
forward_to_part! {
deserialize_bool,
deserialize_char,
deserialize_str,
deserialize_string,
deserialize_bytes,
deserialize_byte_buf,
deserialize_unit,
deserialize_u8,
deserialize_u16,
deserialize_u32,
deserialize_u64,
deserialize_i8,
deserialize_i16,
deserialize_i32,
deserialize_i64,
deserialize_f32,
deserialize_f64,
deserialize_option,
deserialize_identifier,
deserialize_map,
}
}
#[cfg(test)]
mod tests {
use std::borrow::Cow;
use assert_matches::assert_matches;
use super::ValOrVec;
#[test]
fn cow_borrowed() {
let mut x = ValOrVec::Val(Cow::Borrowed("a"));
x.push(Cow::Borrowed("b"));
x.push(Cow::Borrowed("c"));
let v = assert_matches!(x, ValOrVec::Vec(v) => v);
assert_eq!(v, vec!["a", "b", "c"]);
}
#[test]
fn cow_owned() {
let mut x = ValOrVec::Val(Cow::from("a".to_owned()));
x.push(Cow::from("b".to_owned()));
x.push(Cow::from("c".to_owned()));
let v = assert_matches!(
x,
ValOrVec::Vec(v) => v
);
assert_eq!(v, vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]);
}
}

488
crates/ruma-common/src/serde/urlencoded/ser.rs
View File

@ -1,488 +0,0 @@
//! Serialization support for the `application/x-www-form-urlencoded` format.
mod key;
mod pair;
mod part;
mod value;
use std::{borrow::Cow, error, fmt, str};
use form_urlencoded::{Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget};
use serde::ser;
/// Serializes a value into a `application/x-www-form-urlencoded` `String` buffer.
///
/// ```
/// let meal = &[("bread", "baguette"), ("cheese", "comté"), ("meat", "ham"), ("fat", "butter")];
///
/// assert_eq!(
/// ruma_common::serde::urlencoded::to_string(meal),
/// Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned())
/// );
/// ```
pub fn to_string<T: ser::Serialize>(input: T) -> Result<String, Error> {
let mut urlencoder = UrlEncodedSerializer::new("".to_owned());
input.serialize(Serializer::new(&mut urlencoder))?;
Ok(urlencoder.finish())
}
/// A serializer for the `application/x-www-form-urlencoded` format.
///
/// * Supported top-level inputs are structs, maps and sequences of pairs, with or without a given
/// length.
///
/// * Supported keys and values are integers, bytes (if convertible to strings), unit structs and
/// unit variants.
///
/// * Newtype structs defer to their inner values.
pub struct Serializer<'input, 'output, Target: UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
}
impl<'input, 'output, Target: UrlEncodedTarget> Serializer<'input, 'output, Target> {
/// Returns a new `Serializer`.
pub fn new(urlencoder: &'output mut UrlEncodedSerializer<'input, Target>) -> Self {
Serializer { urlencoder }
}
}
/// Errors returned during serializing to `application/x-www-form-urlencoded`.
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Error {
/// UTF-8 validation failed.
Utf8(str::Utf8Error),
/// Something else.
Custom(Cow<'static, str>),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Error::Custom(ref msg) => msg.fmt(f),
Error::Utf8(ref err) => write!(f, "invalid UTF-8: {err}"),
}
}
}
impl error::Error for Error {
/// The lower-level cause of this error, in the case of a `Utf8` error.
fn cause(&self) -> Option<&dyn error::Error> {
match *self {
Error::Custom(_) => None,
Error::Utf8(ref err) => Some(err),
}
}
/// The lower-level source of this error, in the case of a `Utf8` error.
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match *self {
Error::Custom(_) => None,
Error::Utf8(ref err) => Some(err),
}
}
}
impl ser::Error for Error {
fn custom<T: fmt::Display>(msg: T) -> Self {
Error::Custom(format!("{msg}").into())
}
}
/// Sequence serializer.
pub struct SeqSerializer<'input, 'output, Target: UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
}
/// Tuple serializer.
///
/// Mostly used for arrays.
pub struct TupleSerializer<'input, 'output, Target: UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
}
/// Tuple struct serializer.
///
/// Never instantiated, tuple structs are not supported.
pub struct TupleStructSerializer<'input, 'output, T: UrlEncodedTarget> {
inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
}
/// Tuple variant serializer.
///
/// Never instantiated, tuple variants are not supported.
pub struct TupleVariantSerializer<'input, 'output, T: UrlEncodedTarget> {
inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
}
/// Map serializer.
pub struct MapSerializer<'input, 'output, Target: UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
key: Option<Cow<'static, str>>,
}
/// Struct serializer.
pub struct StructSerializer<'input, 'output, Target: UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
}
/// Struct variant serializer.
///
/// Never instantiated, struct variants are not supported.
pub struct StructVariantSerializer<'input, 'output, T: UrlEncodedTarget> {
inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
}
impl<'input, 'output, Target> ser::Serializer for Serializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
type SerializeSeq = SeqSerializer<'input, 'output, Target>;
type SerializeTuple = TupleSerializer<'input, 'output, Target>;
type SerializeTupleStruct = TupleStructSerializer<'input, 'output, Target>;
type SerializeTupleVariant = TupleVariantSerializer<'input, 'output, Target>;
type SerializeMap = MapSerializer<'input, 'output, Target>;
type SerializeStruct = StructSerializer<'input, 'output, Target>;
type SerializeStructVariant = StructVariantSerializer<'input, 'output, Target>;
/// Returns an error.
fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_char(self, _v: char) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_str(self, _value: &str) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns `Ok`.
fn serialize_unit(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
/// Returns `Ok`.
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
/// Returns an error.
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Serializes the inner value, ignoring the newtype name.
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<Self::Ok, Error> {
value.serialize(self)
}
/// Returns an error.
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<Self::Ok, Error> {
Err(Error::top_level())
}
/// Returns `Ok`.
fn serialize_none(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
/// Serializes the given value.
fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<Self::Ok, Error> {
value.serialize(self)
}
/// Serialize a sequence, given length (if any) is ignored.
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
Ok(SeqSerializer { urlencoder: self.urlencoder })
}
/// Returns an error.
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
Ok(TupleSerializer { urlencoder: self.urlencoder })
}
/// Returns an error.
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Error> {
Err(Error::top_level())
}
/// Serializes a map, given length is ignored.
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
Ok(MapSerializer { urlencoder: self.urlencoder, key: None })
}
/// Serializes a struct, given length is ignored.
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Error> {
Ok(StructSerializer { urlencoder: self.urlencoder })
}
/// Returns an error.
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Error> {
Err(Error::top_level())
}
}
impl<'input, 'output, Target> ser::SerializeSeq for SeqSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
value.serialize(pair::PairSerializer::new(self.urlencoder))
}
fn end(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
}
impl<'input, 'output, Target> ser::SerializeTuple for TupleSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
value.serialize(pair::PairSerializer::new(self.urlencoder))
}
fn end(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
}
impl<'input, 'output, Target> ser::SerializeTupleStruct
for TupleStructSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
self.inner.serialize_field(value)
}
fn end(self) -> Result<Self::Ok, Error> {
self.inner.end()
}
}
impl<'input, 'output, Target> ser::SerializeTupleVariant
for TupleVariantSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
self.inner.serialize_field(value)
}
fn end(self) -> Result<Self::Ok, Error> {
self.inner.end()
}
}
impl<'input, 'output, Target> ser::SerializeMap for MapSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_entry<K: ?Sized + ser::Serialize, V: ?Sized + ser::Serialize>(
&mut self,
key: &K,
value: &V,
) -> Result<(), Error> {
let key_sink = key::KeySink::new(|key| {
let value_sink = value::ValueSink::new(self.urlencoder, &key);
value.serialize(part::PartSerializer::new(value_sink))?;
self.key = None;
Ok(())
});
let entry_serializer = part::PartSerializer::new(key_sink);
key.serialize(entry_serializer)
}
fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Error> {
let key_sink = key::KeySink::new(|key| Ok(key.into()));
let key_serializer = part::PartSerializer::new(key_sink);
self.key = Some(key.serialize(key_serializer)?);
Ok(())
}
fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
{
let key = self.key.as_ref().ok_or_else(Error::no_key)?;
let value_sink = value::ValueSink::new(self.urlencoder, key);
value.serialize(part::PartSerializer::new(value_sink))?;
}
self.key = None;
Ok(())
}
fn end(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
}
impl<'input, 'output, Target> ser::SerializeStruct for StructSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Error> {
let value_sink = value::ValueSink::new(self.urlencoder, key);
value.serialize(part::PartSerializer::new(value_sink))
}
fn end(self) -> Result<Self::Ok, Error> {
Ok(self.urlencoder)
}
}
impl<'input, 'output, Target> ser::SerializeStructVariant
for StructVariantSerializer<'input, 'output, Target>
where
Target: UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
type Error = Error;
fn serialize_field<T: ?Sized + ser::Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Error> {
self.inner.serialize_field(key, value)
}
fn end(self) -> Result<Self::Ok, Error> {
self.inner.end()
}
}
impl Error {
fn top_level() -> Self {
let msg = "top-level serializer supports only maps and structs";
Error::Custom(msg.into())
}
fn no_key() -> Self {
let msg = "tried to serialize a value before serializing key";
Error::Custom(msg.into())
}
}

79
crates/ruma-common/src/serde/urlencoded/ser/key.rs
View File

@ -1,79 +0,0 @@
use std::{borrow::Cow, ops::Deref};
use serde::ser;
use super::{part::Sink, Error};
pub enum Key<'key> {
Static(&'static str),
Dynamic(Cow<'key, str>),
}
impl<'key> Deref for Key<'key> {
type Target = str;
fn deref(&self) -> &str {
match *self {
Key::Static(key) => key,
Key::Dynamic(ref key) => key,
}
}
}
impl<'key> From<Key<'key>> for Cow<'static, str> {
fn from(key: Key<'key>) -> Self {
match key {
Key::Static(key) => key.into(),
Key::Dynamic(key) => key.into_owned().into(),
}
}
}
pub struct KeySink<End> {
end: End,
}
impl<End, Ok> KeySink<End>
where
End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
{
pub fn new(end: End) -> Self {
KeySink { end }
}
}
impl<End, Ok> Sink for KeySink<End>
where
End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
{
type Ok = Ok;
type SerializeSeq = ser::Impossible<Self::Ok, Error>;
fn serialize_static_str(self, value: &'static str) -> Result<Ok, Error> {
(self.end)(Key::Static(value))
}
fn serialize_str(self, value: &str) -> Result<Ok, Error> {
(self.end)(Key::Dynamic(value.into()))
}
fn serialize_string(self, value: String) -> Result<Ok, Error> {
(self.end)(Key::Dynamic(value.into()))
}
fn serialize_none(self) -> Result<Ok, Error> {
Err(self.unsupported())
}
fn serialize_some<T: ?Sized + ser::Serialize>(self, _value: &T) -> Result<Ok, Error> {
Err(self.unsupported())
}
fn serialize_seq(self) -> Result<Self::SerializeSeq, Error> {
Err(self.unsupported())
}
fn unsupported(self) -> Error {
Error::Custom("unsupported key".into())
}
}

247
crates/ruma-common/src/serde/urlencoded/ser/pair.rs
View File

@ -1,247 +0,0 @@
use std::{borrow::Cow, mem};
use form_urlencoded::{Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget};
use serde::ser;
use super::{key::KeySink, part::PartSerializer, value::ValueSink, Error};
pub struct PairSerializer<'input, 'target, Target: UrlEncodedTarget> {
urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
state: PairState,
}
impl<'input, 'target, Target> PairSerializer<'input, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
pub fn new(urlencoder: &'target mut UrlEncodedSerializer<'input, Target>) -> Self {
PairSerializer { urlencoder, state: PairState::WaitingForKey }
}
}
impl<'input, 'target, Target> ser::Serializer for PairSerializer<'input, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
type SerializeSeq = ser::Impossible<(), Error>;
type SerializeTuple = Self;
type SerializeTupleStruct = ser::Impossible<(), Error>;
type SerializeTupleVariant = ser::Impossible<(), Error>;
type SerializeMap = ser::Impossible<(), Error>;
type SerializeStruct = ser::Impossible<(), Error>;
type SerializeStructVariant = ser::Impossible<(), Error>;
fn serialize_bool(self, _v: bool) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_i8(self, _v: i8) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_i16(self, _v: i16) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_i32(self, _v: i32) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_i64(self, _v: i64) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_u8(self, _v: u8) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_u16(self, _v: u16) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_u32(self, _v: u32) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_u64(self, _v: u64) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_f32(self, _v: f32) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_f64(self, _v: f64) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_char(self, _v: char) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_str(self, _value: &str) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_bytes(self, _value: &[u8]) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_unit(self) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<(), Error> {
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_none(self) -> Result<(), Error> {
Ok(())
}
fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Error> {
value.serialize(self)
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
Err(Error::unsupported_pair())
}
fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
if len == 2 {
Ok(self)
} else {
Err(Error::unsupported_pair())
}
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Error> {
Err(Error::unsupported_pair())
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Error> {
Err(Error::unsupported_pair())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Error> {
Err(Error::unsupported_pair())
}
}
impl<'input, 'target, Target> ser::SerializeTuple for PairSerializer<'input, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
match mem::replace(&mut self.state, PairState::Done) {
PairState::WaitingForKey => {
let key_sink = KeySink::new(|key| Ok(key.into()));
let key_serializer = PartSerializer::new(key_sink);
self.state = PairState::WaitingForValue { key: value.serialize(key_serializer)? };
Ok(())
}
PairState::WaitingForValue { key } => {
let result = {
let value_sink = ValueSink::new(self.urlencoder, &key);
let value_serializer = PartSerializer::new(value_sink);
value.serialize(value_serializer)
};
if result.is_ok() {
self.state = PairState::Done;
} else {
self.state = PairState::WaitingForValue { key };
}
result
}
PairState::Done => Err(Error::done()),
}
}
fn end(self) -> Result<(), Error> {
if let PairState::Done = self.state {
Ok(())
} else {
Err(Error::not_done())
}
}
}
enum PairState {
WaitingForKey,
WaitingForValue { key: Cow<'static, str> },
Done,
}
impl Error {
fn done() -> Self {
Error::Custom("this pair has already been serialized".into())
}
fn not_done() -> Self {
Error::Custom("this pair has not yet been serialized".into())
}
fn unsupported_pair() -> Self {
Error::Custom("unsupported pair".into())
}
}

205
crates/ruma-common/src/serde/urlencoded/ser/part.rs
View File

@ -1,205 +0,0 @@
use std::str;
use serde::ser;
use super::Error;
pub struct PartSerializer<S> {
sink: S,
}
impl<S: Sink> PartSerializer<S> {
pub fn new(sink: S) -> Self {
PartSerializer { sink }
}
}
pub trait Sink: Sized {
type Ok;
type SerializeSeq: ser::SerializeSeq<Ok = Self::Ok, Error = Error>;
fn serialize_static_str(self, value: &'static str) -> Result<Self::Ok, Error>;
fn serialize_str(self, value: &str) -> Result<Self::Ok, Error>;
fn serialize_string(self, value: String) -> Result<Self::Ok, Error>;
fn serialize_none(self) -> Result<Self::Ok, Error>;
fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<Self::Ok, Error>;
fn serialize_seq(self) -> Result<Self::SerializeSeq, Error>;
fn unsupported(self) -> Error;
}
impl<S: Sink> ser::Serializer for PartSerializer<S> {
type Ok = S::Ok;
type Error = Error;
type SerializeSeq = S::SerializeSeq;
type SerializeTuple = ser::Impossible<S::Ok, Error>;
type SerializeTupleStruct = ser::Impossible<S::Ok, Error>;
type SerializeTupleVariant = ser::Impossible<S::Ok, Error>;
type SerializeMap = ser::Impossible<S::Ok, Error>;
type SerializeStruct = ser::Impossible<S::Ok, Error>;
type SerializeStructVariant = ser::Impossible<S::Ok, Error>;
fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
self.sink.serialize_static_str(if v { "true" } else { "false" })
}
fn serialize_i8(self, v: i8) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_i16(self, v: i16) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_i32(self, v: i32) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_i64(self, v: i64) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_u8(self, v: u8) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_u16(self, v: u16) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_u32(self, v: u32) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_u64(self, v: u64) -> Result<S::Ok, Error> {
self.serialize_integer(v)
}
fn serialize_f32(self, _v: f32) -> Result<S::Ok, Error> {
Err(self.sink.unsupported())
}
fn serialize_f64(self, _v: f64) -> Result<S::Ok, Error> {
Err(self.sink.unsupported())
}
fn serialize_char(self, v: char) -> Result<S::Ok, Error> {
self.sink.serialize_string(v.to_string())
}
fn serialize_str(self, value: &str) -> Result<S::Ok, Error> {
self.sink.serialize_str(value)
}
fn serialize_bytes(self, value: &[u8]) -> Result<S::Ok, Error> {
match str::from_utf8(value) {
Ok(value) => self.sink.serialize_str(value),
Err(err) => Err(Error::Utf8(err)),
}
}
fn serialize_unit(self) -> Result<S::Ok, Error> {
Err(self.sink.unsupported())
}
fn serialize_unit_struct(self, name: &'static str) -> Result<S::Ok, Error> {
self.sink.serialize_static_str(name)
}
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<S::Ok, Error> {
self.sink.serialize_static_str(variant)
}
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<S::Ok, Error> {
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<S::Ok, Error> {
Err(self.sink.unsupported())
}
fn serialize_none(self) -> Result<S::Ok, Error> {
self.sink.serialize_none()
}
fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<S::Ok, Error> {
self.sink.serialize_some(value)
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
self.sink.serialize_seq()
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTuple, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Error> {
Err(self.sink.unsupported())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
Err(self.sink.unsupported())
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Error> {
Err(self.sink.unsupported())
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Error> {
Err(self.sink.unsupported())
}
}
impl<S: Sink> PartSerializer<S> {
fn serialize_integer<I>(self, value: I) -> Result<S::Ok, Error>
where
I: itoa::Integer,
{
let mut buf = itoa::Buffer::new();
let part = buf.format(value);
ser::Serializer::serialize_str(self, part)
}
}

94
crates/ruma-common/src/serde/urlencoded/ser/value.rs
View File

@ -1,94 +0,0 @@
use std::str;
use form_urlencoded::{Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget};
use serde::ser;
use super::{
part::{PartSerializer, Sink},
Error,
};
pub struct ValueSink<'input, 'key, 'target, Target>
where
Target: UrlEncodedTarget,
{
urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
key: &'key str,
nested: bool,
}
impl<'input, 'key, 'target, Target> ValueSink<'input, 'key, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
pub fn new(
urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
key: &'key str,
) -> Self {
ValueSink { urlencoder, key, nested: false }
}
}
impl<'input, 'key, 'target, Target> Sink for ValueSink<'input, 'key, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type SerializeSeq = Self;
fn serialize_str(self, value: &str) -> Result<(), Error> {
self.urlencoder.append_pair(self.key, value);
Ok(())
}
fn serialize_static_str(self, value: &'static str) -> Result<(), Error> {
self.serialize_str(value)
}
fn serialize_string(self, value: String) -> Result<(), Error> {
self.serialize_str(&value)
}
fn serialize_none(self) -> Result<Self::Ok, Error> {
Ok(())
}
fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<Self::Ok, Error> {
value.serialize(PartSerializer::new(self))
}
fn serialize_seq(self) -> Result<Self, Error> {
if self.nested {
Err(self.unsupported())
} else {
Ok(self)
}
}
fn unsupported(self) -> Error {
Error::Custom("unsupported value".into())
}
}
impl<'input, 'key, 'target, Target> ser::SerializeSeq for ValueSink<'input, 'key, 'target, Target>
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: ser::Serialize,
{
value.serialize(PartSerializer::new(ValueSink {
urlencoder: self.urlencoder,
key: self.key,
nested: true,
}))
}
fn end(self) -> Result<Self::Ok, Self::Error> {
Ok(())
}
}

2
crates/ruma-common/tests/serde/mod.rs
View File

@ -1,4 +1,2 @@
mod empty_strings;
mod enum_derive;
mod url_deserialize;
mod url_serialize;

269
crates/ruma-common/tests/serde/url_deserialize.rs
View File

@ -1,269 +0,0 @@
use assert_matches::assert_matches;
use form_urlencoded::Serializer as Encoder;
use ruma_common::serde::urlencoded;
use serde::Deserialize;
#[derive(Deserialize, Debug, PartialEq)]
struct NewType<T>(T);
#[test]
fn deserialize_newtype_i32() {
let result = vec![("field".to_owned(), NewType(11))];
assert_eq!(urlencoded::from_str("field=11"), Ok(result));
}
#[test]
fn deserialize_bytes() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(urlencoded::from_bytes(b"first=23&last=42"), Ok(result));
}
#[test]
fn deserialize_str() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(urlencoded::from_str("first=23&last=42"), Ok(result));
}
#[test]
fn deserialize_borrowed_str() {
let result = vec![("first", 23), ("last", 42)];
assert_eq!(urlencoded::from_str("first=23&last=42"), Ok(result));
}
#[test]
fn deserialize_reader() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(urlencoded::from_reader(b"first=23&last=42" as &[_]), Ok(result));
}
#[test]
fn deserialize_option() {
let result = vec![("first".to_owned(), Some(23)), ("last".to_owned(), Some(42))];
assert_eq!(urlencoded::from_str("first=23&last=42"), Ok(result));
}
#[test]
fn deserialize_unit() {
assert_eq!(urlencoded::from_str(""), Ok(()));
assert_eq!(urlencoded::from_str("&"), Ok(()));
assert_eq!(urlencoded::from_str("&&"), Ok(()));
urlencoded::from_str::<()>("first=23").unwrap_err();
}
#[derive(Deserialize, Debug, PartialEq, Eq)]
enum X {
A,
B,
C,
}
#[test]
fn deserialize_unit_enum() {
let result: Vec<(String, X)> = urlencoded::from_str("one=A&two=B&three=C").unwrap();
assert_eq!(result.len(), 3);
assert!(result.contains(&("one".to_owned(), X::A)));
assert!(result.contains(&("two".to_owned(), X::B)));
assert!(result.contains(&("three".to_owned(), X::C)));
}
#[test]
fn deserialize_unit_type() {
assert_eq!(urlencoded::from_str(""), Ok(()));
}
#[derive(Clone, Copy, Debug, PartialEq, Deserialize)]
struct Params<'a> {
a: usize,
b: &'a str,
c: Option<u8>,
}
#[test]
fn deserialize_struct() {
let de = Params { a: 10, b: "Hello", c: None };
assert_eq!(urlencoded::from_str("a=10&b=Hello"), Ok(de));
assert_eq!(urlencoded::from_str("b=Hello&a=10"), Ok(de));
assert_eq!(urlencoded::from_str("a=10&b=Hello&d=1&d=2"), Ok(de));
}
#[test]
fn deserialize_list_of_str() {
// TODO: It would make sense to support this.
assert_matches!(
urlencoded::from_str::<Vec<(&str, &str)>>("a=a&a=b"),
Err(error) if error.to_string().contains("unsupported")
);
assert_eq!(urlencoded::from_str("a=a&a=b"), Ok(vec![("a", vec!["a", "b"])]));
}
#[test]
fn deserialize_multiple_lists() {
#[derive(Debug, PartialEq, Deserialize)]
struct Lists {
xs: Vec<bool>,
ys: Vec<u32>,
}
assert_eq!(
urlencoded::from_str("xs=true&xs=false&ys=3&ys=2&ys=1"),
Ok(Lists { xs: vec![true, false], ys: vec![3, 2, 1] })
);
assert_eq!(
urlencoded::from_str("ys=3&xs=true&ys=2&xs=false&ys=1"),
Ok(Lists { xs: vec![true, false], ys: vec![3, 2, 1] })
);
}
#[test]
fn deserialize_with_serde_attributes() {
#[derive(Debug, PartialEq, Deserialize)]
struct FieldsWithAttributes {
#[serde(default)]
xs: Vec<bool>,
#[serde(default)]
def: Option<u8>,
#[serde(default, deserialize_with = "ruma_common::serde::empty_string_as_none")]
str: Option<String>,
#[serde(default)]
flag: bool,
}
assert_eq!(
urlencoded::from_str("xs=true&xs=false&def=3&str=&flag=true"),
Ok(FieldsWithAttributes { xs: vec![true, false], def: Some(3), str: None, flag: true })
);
assert_eq!(
urlencoded::from_str(""),
Ok(FieldsWithAttributes { xs: vec![], def: None, str: None, flag: false })
);
}
#[test]
fn deserialize_nested_list() {
urlencoded::from_str::<Vec<(&str, Vec<Vec<bool>>)>>("a=b").unwrap_err();
}
#[test]
fn deserialize_list_of_option() {
assert_eq!(
urlencoded::from_str("list=10&list=100"),
Ok(vec![("list", vec![Some(10), Some(100)])])
);
}
#[test]
fn deserialize_list_of_newtype() {
assert_eq!(urlencoded::from_str("list=test"), Ok(vec![("list", vec![NewType("test")])]));
}
#[test]
fn deserialize_list_of_enum() {
assert_eq!(
urlencoded::from_str("item=A&item=B&item=C"),
Ok(vec![("item", vec![X::A, X::B, X::C])])
);
}
#[derive(Debug, Deserialize, PartialEq)]
struct Wrapper<T> {
item: T,
}
#[derive(Debug, PartialEq, Deserialize)]
struct NewStruct<'a> {
#[serde(borrow)]
list: Vec<&'a str>,
}
#[derive(Debug, PartialEq, Deserialize)]
struct Struct<'a> {
#[serde(borrow)]
list: Vec<Option<&'a str>>,
}
#[derive(Debug, PartialEq, Deserialize)]
struct NumList {
list: Vec<u8>,
}
#[derive(Debug, PartialEq, Deserialize)]
struct ListStruct {
list: Vec<NewType<usize>>,
}
#[test]
fn deserialize_newstruct() {
let de = NewStruct { list: vec!["hello", "world"] };
assert_eq!(urlencoded::from_str("list=hello&list=world"), Ok(de));
}
#[test]
fn deserialize_numlist() {
let de = NumList { list: vec![1, 2, 3, 4] };
assert_eq!(urlencoded::from_str("list=1&list=2&list=3&list=4"), Ok(de));
}
#[derive(Debug, Deserialize, PartialEq)]
struct Nested<T> {
item: T,
}
#[derive(Debug, Deserialize, PartialEq)]
struct Inner<'a> {
c: &'a str,
a: usize,
b: &'a str,
}
#[derive(Debug, Deserialize, PartialEq)]
struct InnerList<T> {
list: Vec<T>,
}
#[test]
#[ignore]
fn deserialize_nested_struct() {
let mut encoder = Encoder::new(String::new());
let nested = Nested { item: Inner { c: "hello", a: 10, b: "bye" } };
assert_eq!(
urlencoded::from_str(
&encoder.append_pair("item", r#"{"c":"hello","a":10,"b":"bye"}"#).finish(),
),
Ok(nested)
);
}
#[test]
#[ignore]
fn deserialize_nested_struct_with_list() {
let mut encoder = Encoder::new(String::new());
let nested = Nested { item: InnerList { list: vec![1, 2, 3] } };
assert_eq!(
urlencoded::from_str(&encoder.append_pair("item", r#"{"list":[1,2,3]}"#).finish()),
Ok(nested)
);
}
#[test]
#[ignore]
fn deserialize_nested_list_option() {
let mut encoder = Encoder::new(String::new());
let nested = Nested { item: InnerList { list: vec![Some(1), Some(2), None] } };
assert_eq!(
urlencoded::from_str(&encoder.append_pair("item", r#"{"list":[1,2,null]}"#).finish()),
Ok(nested)
);
}

166
crates/ruma-common/tests/serde/url_serialize.rs
View File

@ -1,166 +0,0 @@
use assert_matches::assert_matches;
use form_urlencoded::Serializer as Encoder;
use ruma_common::serde::urlencoded::{self, ser::Error};
use serde::Serialize;
#[derive(Serialize)]
struct NewType<T>(T);
#[test]
fn serialize_newtype_i32() {
let params = &[("field", Some(NewType(11)))];
assert_eq!(urlencoded::to_string(params), Ok("field=11".to_owned()));
}
#[test]
fn serialize_option_map_int() {
let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
assert_eq!(urlencoded::to_string(params), Ok("first=23&last=42".to_owned()));
}
#[test]
fn serialize_option_map_string() {
let params = &[("first", Some("hello")), ("middle", None), ("last", Some("world"))];
assert_eq!(urlencoded::to_string(params), Ok("first=hello&last=world".to_owned()));
}
#[test]
fn serialize_option_map_bool() {
let params = &[("one", Some(true)), ("two", Some(false))];
assert_eq!(urlencoded::to_string(params), Ok("one=true&two=false".to_owned()));
}
#[test]
fn serialize_map_bool() {
let params = &[("one", true), ("two", false)];
assert_eq!(urlencoded::to_string(params), Ok("one=true&two=false".to_owned()));
}
#[derive(Serialize)]
enum X {
A,
B,
C,
}
#[test]
fn serialize_unit_enum() {
let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
assert_eq!(urlencoded::to_string(params), Ok("one=A&two=B&three=C".to_owned()));
}
#[derive(Serialize)]
struct Unit;
#[test]
fn serialize_unit_struct() {
assert_eq!(urlencoded::to_string(Unit), Ok("".to_owned()));
}
#[test]
fn serialize_unit_type() {
assert_eq!(urlencoded::to_string(()), Ok("".to_owned()));
}
#[test]
fn serialize_list_of_str() {
let params = &[("list", vec!["hello", "world"])];
assert_eq!(urlencoded::to_string(params), Ok("list=hello&list=world".to_owned()));
}
#[test]
fn serialize_multiple_lists() {
#[derive(Serialize)]
struct Lists {
xs: Vec<bool>,
ys: Vec<u32>,
}
let params = Lists { xs: vec![true, false], ys: vec![3, 2, 1] };
assert_eq!(urlencoded::to_string(params), Ok("xs=true&xs=false&ys=3&ys=2&ys=1".to_owned()));
}
#[test]
fn serialize_nested_list() {
let params = &[("list", vec![vec![0_u8]])];
assert_matches!(
urlencoded::to_string(params),
Err(Error::Custom(s)) if s.contains("unsupported")
);
}
#[test]
fn serialize_list_of_option() {
let params = &[("list", vec![Some(10), Some(100)])];
assert_eq!(urlencoded::to_string(params), Ok("list=10&list=100".to_owned()));
}
#[test]
fn serialize_list_of_newtype() {
let params = &[("list", vec![NewType("test".to_owned())])];
assert_eq!(urlencoded::to_string(params), Ok("list=test".to_owned()));
}
#[test]
fn serialize_list_of_enum() {
let params = &[("item", vec![X::A, X::B, X::C])];
assert_eq!(urlencoded::to_string(params), Ok("item=A&item=B&item=C".to_owned()));
}
#[test]
fn serialize_map() {
let mut s = std::collections::BTreeMap::new();
s.insert("hello", "world");
s.insert("seri", "alize");
s.insert("matrix", "ruma");
let encoded = urlencoded::to_string(s).unwrap();
assert_eq!("hello=world&matrix=ruma&seri=alize", encoded);
}
#[derive(Serialize)]
struct Nested<T> {
item: T,
}
#[derive(Serialize)]
struct Inner {
c: String,
a: usize,
b: String,
}
#[derive(Debug, Serialize, PartialEq)]
struct InnerList<T> {
list: Vec<T>,
}
#[test]
#[ignore]
fn serialize_nested_struct() {
let mut encoder = Encoder::new(String::new());
let s = Nested { item: Inner { c: "hello".into(), a: 10, b: "bye".into() } };
assert_eq!(
encoder.append_pair("item", r#"{"c":"hello","a":10,"b":"bye"}"#).finish(),
urlencoded::to_string(s).unwrap()
);
}
#[test]
#[ignore]
fn serialize_nested_struct_with_list() {
let mut encoder = Encoder::new(String::new());
let s = Nested { item: InnerList { list: vec![1, 2, 3] } };
assert_eq!(
encoder.append_pair("item", r#"{"list":[1,2,3]}"#).finish(),
urlencoded::to_string(s).unwrap()
);
}

11
crates/ruma-macros/src/api/request/incoming.rs
View File

@ -8,6 +8,7 @@ impl Request {
pub fn expand_incoming(&self, ruma_common: &TokenStream) -> TokenStream {
let http = quote! { #ruma_common::exports::http };
let serde = quote! { #ruma_common::exports::serde };
let serde_html_form = quote! { #ruma_common::exports::serde_html_form };
let serde_json = quote! { #ruma_common::exports::serde_json };
let error_ty = &self.error_ty;
@ -36,9 +37,8 @@ impl Request {
let field_name = field.ident.as_ref().expect("expected field to have an identifier");
let parse = quote! {
#( #cfg_attrs )*
let #field_name = #ruma_common::serde::urlencoded::from_str(
&request.uri().query().unwrap_or(""),
)?;
let #field_name =
#serde_html_form::from_str(&request.uri().query().unwrap_or(""))?;
};
(
@ -55,9 +55,8 @@ impl Request {
);
let parse = quote! {
let request_query: RequestQuery = #ruma_common::serde::urlencoded::from_str(
&request.uri().query().unwrap_or("")
)?;
let request_query: RequestQuery =
#serde_html_form::from_str(&request.uri().query().unwrap_or(""))?;
#decls
};

11
crates/ruma-macros/src/api/request/outgoing.rs
View File

@ -8,6 +8,7 @@ impl Request {
pub fn expand_outgoing(&self, ruma_common: &TokenStream) -> TokenStream {
let bytes = quote! { #ruma_common::exports::bytes };
let http = quote! { #ruma_common::exports::http };
let serde_html_form = quote! { #ruma_common::exports::serde_html_form };
let error_ty = &self.error_ty;
@ -22,9 +23,9 @@ impl Request {
// the field with the query_map attribute doesn't implement
// `IntoIterator<Item = (String, String)>`.
//
// This is necessary because the `ruma_common::serde::urlencoded::to_string` call will
// result in a runtime error when the type cannot be encoded as a list key-value
// pairs (?key1=value1&key2=value2).
// This is necessary because the `serde_html_form::to_string` call will result in a
// runtime error when the type cannot be encoded as a list key-value pairs
// (?key1=value1&key2=value2).
//
// By asserting that it implements the iterator trait, we can ensure that it won't
// fail.
@ -38,7 +39,7 @@ impl Request {
let request_query = RequestQuery(self.#field_name);
assert_trait_impl(&request_query.0);
&#ruma_common::serde::urlencoded::to_string(request_query)?
&#serde_html_form::to_string(request_query)?
}}
} else if self.has_query_fields() {
let request_query_init_fields = struct_init_fields(
@ -51,7 +52,7 @@ impl Request {
#request_query_init_fields
};
&#ruma_common::serde::urlencoded::to_string(request_query)?
&#serde_html_form::to_string(request_query)?
}}
} else {
quote! { "" }