Serialize bytes as percent-encoded data.

Fixes #40.

Thanks to @faulesocke for reporting.

3 files changed, 8 insertions, 57 deletions

diff --git a/src/error.rs b/src/error.rs
index 6aac25f..b7c2042 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -21,10 +21,6 @@ pub enum Error {
     #[error("unsupported type for serialization")]
     Unsupported,
 
-    /// Error decoding `BASE64URL` data
-    #[error(transparent)]
-    Decoding(#[from] data_encoding::DecodeError),
-
     /// Error proessing UTF-8 for a `String`
     #[error(transparent)]
     FromUtf8(#[from] string::FromUtf8Error),
diff --git a/src/lib.rs b/src/lib.rs
index bad68e9..4604859 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -160,50 +160,6 @@
 //!
 //! Support for `actix-web 2.0.0` is available via the `actix2` feature.
 
-#![allow()]
-#![deny(
-    arithmetic_overflow,
-    const_err,
-    dead_code,
-    deprecated,
-    improper_ctypes,
-    missing_docs,
-    mutable_transmutes,
-    no_mangle_const_items,
-    non_camel_case_types,
-    non_shorthand_field_patterns,
-    non_snake_case,
-    non_upper_case_globals,
-    overflowing_literals,
-    path_statements,
-    stable_features,
-    trivial_casts,
-    trivial_numeric_casts,
-    unconditional_recursion,
-    unknown_crate_types,
-    unknown_lints,
-    unreachable_code,
-    unsafe_code,
-    unstable_features,
-    unused_allocation,
-    unused_assignments,
-    unused_attributes,
-    unused_comparisons,
-    unused_extern_crates,
-    unused_features,
-    unused_imports,
-    unused_import_braces,
-    unused_must_use,
-    unused_mut,
-    unused_parens,
-    unused_qualifications,
-    unused_results,
-    unused_unsafe,
-    unused_variables,
-    variant_size_differences,
-    while_true
-)]
-
 #[macro_use]
 extern crate serde;
 
diff --git a/src/ser.rs b/src/ser.rs
index bd2e5c8..6107694 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,6 +1,5 @@
 //! Serialization support for querystrings.
 
-use data_encoding::BASE64URL_NOPAD as BASE64;
 use percent_encoding::{percent_encode, AsciiSet, NON_ALPHANUMERIC};
 use serde::ser;
 
@@ -132,7 +131,7 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> {
         self.key = Some(key)
     }
 
-    fn write_value(&mut self, value: &str) -> Result<()> {
+    fn write_value(&mut self, value: &[u8]) -> Result<()> {
         if let Some(ref key) = self.key {
             write!(
                 self.writer,
@@ -144,7 +143,7 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> {
                     "&"
                 },
                 key,
-                percent_encode(value.as_bytes(), QS_ENCODE_SET)
+                percent_encode(value, QS_ENCODE_SET)
                     .map(replace_space)
                     .collect::<String>()
             )
@@ -176,7 +175,7 @@ macro_rules! serialize_as_string {
     (Qs $($ty:ty => $meth:ident,)*) => {
         $(
             fn $meth(self, v: $ty) -> Result<Self::Ok> {
-                self.write_value(&v.to_string())
+                self.write_value(&v.to_string().as_bytes())
             }
         )*
     };
@@ -218,16 +217,16 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
     }
 
     fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
-        self.write_value(&BASE64.encode(value))
+        self.write_value(&value)
     }
 
     fn serialize_unit(self) -> Result<Self::Ok> {
-        self.write_value("")
+        self.write_value(&[])
     }
 
     /// Returns an error.
     fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
-        self.write_value(name)
+        self.write_value(name.as_bytes())
     }
 
     /// Returns an error.
@@ -237,7 +236,7 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
         _variant_index: u32,
         variant: &'static str,
     ) -> Result<Self::Ok> {
-        self.write_value(variant)
+        self.write_value(variant.as_bytes())
     }
 
     /// Returns an error.
@@ -510,7 +509,7 @@ impl ser::Serializer for StringSerializer {
     }
 
     fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
-        Ok(BASE64.encode(value))
+        Ok(String::from_utf8_lossy(value).to_string())
     }
 
     /// Returns an error.