Integrate serde_urlencoded fork

Cargo.toml

@@ -6,15 +6,16 @@ license = "MIT"
 authors = [
     "Jonas Platte <jplatte@posteo.de>",
     "Isaiah Inuwa <isaiah.inuwa@gmail.com>",
+    "Anthony Ramine <n.oxyde@gmail.com>",
 ]
 version = "0.1.0"
 repository = "https://github.com/ruma/ruma-serde"
 edition = "2018"
 
 [dependencies]
+dtoa = "0.4.5"
 js_int = { version = "0.1.4", features = ["serde"] }
-serde = "1.0.106"
-serde_json = "1.0.51"
-
-[dev-dependencies]
+itoa = "0.4.5"
 serde = { version = "1.0.106", features = ["derive"] }
+serde_json = "1.0.51"
+url = "2.1.1"

LICENSE

@@ -1,4 +1,5 @@
-Copyright (c) 2016 Jimmy Cuadra
+Copyright (c) 2016 - 2019 Anthony Ramine
+Copyright (c) 2020 Jonas Platte
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,8 @@
+# ruma-serde
+
+This crate contains (de)serialization helpers for other ruma crates.
+
+Part of that is a fork of serde_urlencoded, with support for sequences in `Deserialize` /
+`Serialize` structs (e.g. `Vec<Something>`) that are (de)serialized as `field=val1&field=val2`
+(instead of the more common `field[]=val1&field[]=val2` format supported by other crates like
+`serde_qs`).

src/lib.rs

@@ -3,6 +3,7 @@
 pub mod duration;
 pub mod json_string;
 pub mod time;
+pub mod urlencoded;
 
 pub fn is_default<T: Default + PartialEq>(val: &T) -> bool {
     val == &T::default()

src/urlencoded/de.rs

@@ -23,7 +23,7 @@ pub use serde::de::value::Error;
 /// ];
 ///
 /// assert_eq!(
-///     serde_urlencoded::from_bytes::<Vec<(String, String)>>(
+///     ruma_serde::urlencoded::from_bytes::<Vec<(String, String)>>(
 ///         b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),
 ///     Ok(meal));
 /// ```
@@ -45,7 +45,7 @@ where
 /// ];
 ///
 /// assert_eq!(
-///     serde_urlencoded::from_str::<Vec<(String, String)>>(
+///     ruma_serde::urlencoded::from_str::<Vec<(String, String)>>(
 ///         "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),
 ///     Ok(meal));
 /// ```

src/urlencoded/ser.rs

@@ -12,7 +12,7 @@ use url::form_urlencoded::{
     Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
 };
 
-use crate::error::{Error, Result};
+use crate::urlencoded::error::{Error, Result};
 
 /// Serializes a value into a `application/x-www-form-urlencoded` `String` buffer.
 ///
@@ -25,7 +25,7 @@ use crate::error::{Error, Result};
 /// ];
 ///
 /// assert_eq!(
-///     serde_urlencoded::to_string(meal),
+///     ruma_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> {

src/urlencoded/ser/key.rs

@@ -2,7 +2,7 @@ use std::{borrow::Cow, ops::Deref};
 
 use serde::Serialize;
 
-use crate::ser::{part::Sink, Error};
+use super::{part::Sink, Error};
 
 pub enum Key<'key> {
     Static(&'static str),

src/urlencoded/ser/pair.rs

@@ -7,7 +7,7 @@ use url::form_urlencoded::{
     Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
 };
 
-use crate::{
+use crate::urlencoded::{
     error::{Error, Result},
     ser::{key::KeySink, part::PartSerializer, value::ValueSink},
 };

src/urlencoded/ser/part.rs

@@ -4,7 +4,7 @@ use dtoa;
 use itoa;
 use serde::ser;
 
-use crate::error::Error;
+use crate::urlencoded::error::Error;
 pub struct PartSerializer<S> {
     sink: S,
 }

src/urlencoded/ser/value.rs

@@ -5,7 +5,7 @@ use url::form_urlencoded::{
     Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
 };
 
-use crate::{
+use crate::urlencoded::{
     error::Error,
     ser::part::{PartSerializer, Sink},
 };

tests/url_deserialize.rs

@@ -1,3 +1,4 @@
+use ruma_serde::urlencoded;
 use serde::Deserialize;
 
 #[derive(Deserialize, Debug, PartialEq)]
@@ -7,31 +8,28 @@ struct NewType<T>(T);
 fn deserialize_newtype_i32() {
     let result = vec![("field".to_owned(), NewType(11))];
 
-    assert_eq!(serde_urlencoded::from_str("field=11"), Ok(result));
+    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!(
-        serde_urlencoded::from_bytes(b"first=23&last=42"),
-        Ok(result)
-    );
+    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!(serde_urlencoded::from_str("first=23&last=42"), Ok(result));
+    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!(serde_urlencoded::from_str("first=23&last=42"), Ok(result));
+    assert_eq!(urlencoded::from_str("first=23&last=42"), Ok(result));
 }
 
 #[test]
@@ -39,7 +37,7 @@ fn deserialize_reader() {
     let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
 
     assert_eq!(
-        serde_urlencoded::from_reader(b"first=23&last=42" as &[_]),
+        urlencoded::from_reader(b"first=23&last=42" as &[_]),
         Ok(result)
     );
 }
@@ -50,15 +48,15 @@ fn deserialize_option() {
         ("first".to_owned(), Some(23)),
         ("last".to_owned(), Some(42)),
     ];
-    assert_eq!(serde_urlencoded::from_str("first=23&last=42"), Ok(result));
+    assert_eq!(urlencoded::from_str("first=23&last=42"), Ok(result));
 }
 
 #[test]
 fn deserialize_unit() {
-    assert_eq!(serde_urlencoded::from_str(""), Ok(()));
-    assert_eq!(serde_urlencoded::from_str("&"), Ok(()));
-    assert_eq!(serde_urlencoded::from_str("&&"), Ok(()));
-    assert!(serde_urlencoded::from_str::<()>("first=23").is_err());
+    assert_eq!(urlencoded::from_str(""), Ok(()));
+    assert_eq!(urlencoded::from_str("&"), Ok(()));
+    assert_eq!(urlencoded::from_str("&&"), Ok(()));
+    assert!(urlencoded::from_str::<()>("first=23").is_err());
 }
 
 #[derive(Deserialize, Debug, PartialEq, Eq)]
@@ -76,15 +74,12 @@ fn deserialize_unit_enum() {
         ("three".to_owned(), X::C),
     ];
 
-    assert_eq!(
-        serde_urlencoded::from_str("one=A&two=B&three=C"),
-        Ok(result)
-    );
+    assert_eq!(urlencoded::from_str("one=A&two=B&three=C"), Ok(result));
 }
 
 #[test]
 fn deserialize_unit_type() {
-    assert_eq!(serde_urlencoded::from_str(""), Ok(()));
+    assert_eq!(urlencoded::from_str(""), Ok(()));
 }
 
 #[derive(Debug, Deserialize, PartialEq)]
@@ -128,7 +123,7 @@ fn deserialize_mapstruct() {
     };
     assert_eq!(
         de,
-        serde_urlencoded::from_str::<MapStruct>("a=10&b=Hello").unwrap()
+        urlencoded::from_str::<MapStruct>("a=10&b=Hello").unwrap()
     );
 }
 
@@ -139,8 +134,7 @@ fn deserialize_newstruct() {
     };
     assert_eq!(
         de,
-        serde_urlencoded::from_str::<NewStruct>("list=hello&list=world")
-            .unwrap()
+        urlencoded::from_str::<NewStruct>("list=hello&list=world").unwrap()
     );
 }
 
@@ -151,8 +145,7 @@ fn deserialize_numlist() {
     };
     assert_eq!(
         de,
-        serde_urlencoded::from_str::<NumList>("list=1&list=2&list=3&list=4")
-            .unwrap()
+        urlencoded::from_str::<NumList>("list=1&list=2&list=3&list=4").unwrap()
     );
 }
 
@@ -162,9 +155,7 @@ fn deserialize_vec_bool() {
         Wrapper {
             item: vec![true, false, false]
         },
-        serde_urlencoded::from_str::<Wrapper<_>>(
-            "item=true&item=false&item=false"
-        )
+        urlencoded::from_str::<Wrapper<_>>("item=true&item=false&item=false")
             .unwrap()
     );
 }
@@ -179,9 +170,7 @@ fn deserialize_vec_string() {
                 "hello".to_string()
             ],
         },
-        serde_urlencoded::from_str::<Wrapper<_>>(
-            "item=hello&item=matrix&item=hello"
-        )
+        urlencoded::from_str::<Wrapper<_>>("item=hello&item=matrix&item=hello")
             .unwrap()
     );
 }
@@ -192,8 +181,5 @@ fn deserialize_struct_unit_enum() {
         item: vec![X::A, X::B, X::C],
     };
 
-    assert_eq!(
-        serde_urlencoded::from_str("item=A&item=B&item=C"),
-        Ok(result)
-    );
+    assert_eq!(urlencoded::from_str("item=A&item=B&item=C"), Ok(result));
 }

tests/url_serialize.rs

@@ -1,3 +1,4 @@
+use ruma_serde::urlencoded;
 use serde::Serialize;
 
 #[derive(Serialize)]
@@ -6,10 +7,7 @@ struct NewType<T>(T);
 #[test]
 fn serialize_newtype_i32() {
     let params = &[("field", Some(NewType(11)))];
-    assert_eq!(
-        serde_urlencoded::to_string(params),
-        Ok("field=11".to_owned())
-    );
+    assert_eq!(urlencoded::to_string(params), Ok("field=11".to_owned()));
 }
 
 #[test]
@@ -17,7 +15,7 @@ fn serialize_option_map_int() {
     let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
 
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("first=23&last=42".to_owned())
     );
 }
@@ -31,7 +29,7 @@ fn serialize_option_map_string() {
     ];
 
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("first=hello&last=world".to_owned())
     );
 }
@@ -41,7 +39,7 @@ fn serialize_option_map_bool() {
     let params = &[("one", Some(true)), ("two", Some(false))];
 
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("one=true&two=false".to_owned())
     );
 }
@@ -51,7 +49,7 @@ fn serialize_map_bool() {
     let params = &[("one", true), ("two", false)];
 
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("one=true&two=false".to_owned())
     );
 }
@@ -67,7 +65,7 @@ enum X {
 fn serialize_unit_enum() {
     let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("one=A&two=B&three=C".to_owned())
     );
 }
@@ -77,12 +75,12 @@ struct Unit;
 
 #[test]
 fn serialize_unit_struct() {
-    assert_eq!(serde_urlencoded::to_string(Unit), Ok("".to_owned()));
+    assert_eq!(urlencoded::to_string(Unit), Ok("".to_owned()));
 }
 
 #[test]
 fn serialize_unit_type() {
-    assert_eq!(serde_urlencoded::to_string(()), Ok("".to_owned()));
+    assert_eq!(urlencoded::to_string(()), Ok("".to_owned()));
 }
 
 #[derive(Serialize)]
@@ -112,7 +110,7 @@ fn serialize_newstruct() {
     };
     assert_eq!(
         "list=hello&list=world".to_string(),
-        serde_urlencoded::to_string(s).unwrap()
+        urlencoded::to_string(s).unwrap()
     );
 }
 
@@ -122,7 +120,7 @@ fn serialize_vec_bool() {
         item: vec![true, false, false],
     };
     assert_eq!(
-        serde_urlencoded::to_string(params).unwrap(),
+        urlencoded::to_string(params).unwrap(),
         "item=true&item=false&item=false".to_owned()
     );
 }
@@ -133,7 +131,7 @@ fn serialize_vec_num() {
         item: vec![0, 1, 2],
     };
     assert_eq!(
-        serde_urlencoded::to_string(params).unwrap(),
+        urlencoded::to_string(params).unwrap(),
         "item=0&item=1&item=2".to_owned()
     );
 }
@@ -144,7 +142,7 @@ fn serialize_vec_str() {
         item: vec!["hello", "world", "hello"],
     };
     assert_eq!(
-        serde_urlencoded::to_string(params).unwrap(),
+        urlencoded::to_string(params).unwrap(),
         "item=hello&item=world&item=hello".to_owned()
     );
 }
@@ -156,7 +154,7 @@ fn serialize_struct_opt() {
     };
     assert_eq!(
         "list=hello&list=world".to_string(),
-        serde_urlencoded::to_string(s).unwrap()
+        urlencoded::to_string(s).unwrap()
     );
 }
 
@@ -167,7 +165,7 @@ fn serialize_struct_newtype() {
     };
     assert_eq!(
         "list=0&list=1".to_string(),
-        serde_urlencoded::to_string(s).unwrap()
+        urlencoded::to_string(s).unwrap()
     );
 }
 
@@ -177,7 +175,7 @@ fn serialize_struct_unit_enum() {
         item: vec![X::A, X::B, X::C],
     };
     assert_eq!(
-        serde_urlencoded::to_string(params),
+        urlencoded::to_string(params),
         Ok("item=A&item=B&item=C".to_owned())
     );
 }
@@ -189,6 +187,6 @@ fn serialize_map() {
     s.insert("seri", "alize");
     s.insert("matrix", "ruma");
 
-    let encoded = serde_urlencoded::to_string(s).unwrap();
+    let encoded = urlencoded::to_string(s).unwrap();
     assert_eq!("hello=world&matrix=ruma&seri=alize", encoded);
 }

urlencoded/.gitignore

@@ -1,2 +0,0 @@
-target
-Cargo.lock

urlencoded/.travis.yml

@@ -1,8 +0,0 @@
-language: rust
-rust:
-  - nightly
-  - beta
-  - stable
-branches:
-  except:
-    - staging.tmp

urlencoded/LICENSE-APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

urlencoded/LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2016 Anthony Ramine
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

urlencoded/README.md

@@ -1,50 +0,0 @@
-`x-www-form-urlencoded` meets Serde
-===================================
-
-This crate is a Rust library for serialising to and deserialising from
-the [`application/x-www-form-urlencoded`][urlencoded] format. It is built
-upon [Serde], a high performance generic serialization framework and [rust-url],
-a URL parser for Rust.
-
-[rust-url]: https://github.com/servo/rust-url
-[Serde]: https://github.com/serde-rs/serde
-[urlencoded]: https://url.spec.whatwg.org/#application/x-www-form-urlencoded
-
-Installation
-============
-
-This crate works with Cargo and can be found on
-[crates.io] with a `Cargo.toml` like:
-
-```toml
-[dependencies]
-serde_urlencoded = "0.5.1"
-```
-
-[crates.io]: https://crates.io/crates/serde_urlencoded
-
-## Getting help
-
-Serde developers live in the #serde channel on
-[`irc.mozilla.org`](https://wiki.mozilla.org/IRC) and most rust-url developers
-live in the #servo one. The #rust channel is also a good resource with generally
-faster response time but less specific knowledge about Serde, rust-url or this
-crate. If IRC is not your thing, we are happy to respond to [GitHub
-issues](https://github.com/nox/serde_urlencoded/issues/new) as well.
-
-## License
-
-serde_urlencoded is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in serde_urlencoded by you, as defined in the Apache-2.0 license,
-shall be dual licensed as above, without any additional terms or conditions.

urlencoded/bors.toml

@@ -1 +0,0 @@
-status = ["continuous-integration/travis-ci/push"]