Add stricter lints.

4 files changed, 69 insertions, 16 deletions

diff --git a/src/de/mod.rs b/src/de/mod.rs
index 0f3aa10..03e4065 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -145,10 +145,8 @@ pub fn from_reader<'de, T, R>(mut reader: R) -> Result<T>
           R: Read,
 {
     let mut buf = vec![];
-    reader.read_to_end(&mut buf)
-        .map_err(|e| {
-            ErrorKind::Io(e)
-        })?;
+    let _ = reader.read_to_end(&mut buf)
+        .map_err(Error::from)?;
     from_bytes(&buf)
 }
 
@@ -177,7 +175,7 @@ impl QsDeserializer {
     }
 
     /// Returns a new `QsDeserializer`.
-    fn with_config(config: &Config, input: &[u8]) -> Self {
+    pub fn with_config(config: &Config, input: &[u8]) -> Self {
         let decoded = percent_encoding::percent_decode(input);
         parse::Parser::new(decoded, vec![], None, config.max_depth()).as_deserializer()
 
diff --git a/src/de/parse.rs b/src/de/parse.rs
index 1d5e5a8..74d31a5 100644
--- a/src/de/parse.rs
+++ b/src/de/parse.rs
@@ -40,39 +40,41 @@ impl Default for Config {
 }
 
 impl Config {
+    /// Construct a new `Config` with the specified maximum depth of nesting.
     pub fn with_max_depth(depth: usize) -> Config {
         Config {
             max_depth: depth
         }
     }
 
+    /// Get maximum depth parameter.
     pub fn max_depth(&self) -> usize {
         self.max_depth
     }
 }
 
 impl Config {
+    /// Deserializes a querystring from a `&[u8]` using this `Config`.
     pub fn deserialize_bytes<'de, T: de::Deserialize<'de>>(&self,
                                                  input: &[u8])
                                                  -> Result<T> {
         T::deserialize(QsDeserializer::with_config(self, input))
     }
 
+    /// Deserializes a querystring from a `&str` using this `Config`.
     pub fn deserialize_str<'de, T: de::Deserialize<'de>>(&self,
                                                input: &str)
                                                -> Result<T> {
         self.deserialize_bytes(input.as_bytes())
     }
 
+    /// Deserializes a querystring from a reader using this `Config`.
     pub fn deserialize_reader<'de, T, R>(&self, mut reader: R) -> Result<T>
         where T: de::Deserialize<'de>,
               R: Read,
     {
         let mut buf = vec![];
-        reader.read_to_end(&mut buf)
-            .map_err(|e| {
-                ErrorKind::Io(e)
-            })?;
+        let _ = reader.read_to_end(&mut buf).map_err(Error::from)?;
         self.deserialize_bytes(&buf)
     }
 }
@@ -111,15 +113,17 @@ fn insert_into_map(node: &mut Level, key: String, value: String) {
     if let Level::Nested(ref mut map) = *node {
         match map.entry(key) {
             Entry::Occupied(mut o) => {
-                o.insert(Level::Invalid("Multiple values for one key"));
+                // Throw away old result; map is now invalid anyway.
+                let _ = o.insert(Level::Invalid("Multiple values for one key"));
             },
             Entry::Vacant(vm) => {
-                vm.insert(Level::Flat(value));
+                // Map is empty, result is None
+                let _ = vm.insert(Level::Flat(value));
             },
         }
     } else {
         let mut map = BTreeMap::default();
-        map.insert(key, Level::Flat(value));
+        let _ = map.insert(key, Level::Flat(value));
         *node = Level::Nested(map);
     }
 }
@@ -141,7 +145,7 @@ impl<I: Iterator<Item = u8>> Parser<I> {
         }
         let iter = match root {
             Level::Nested(map) => map.into_iter(),
-            _ => panic!("root node should never be able to converted to anything else. Something went seriously wrong."),
+            _ => BTreeMap::default().into_iter()
         };
         QsDeserializer {
             iter: iter,
diff --git a/src/lib.rs b/src/lib.rs
index 3bbf62d..7eed510 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -66,11 +66,60 @@
 //! assert_eq!(rec_params, params);
 //!
 //! # }
+
+#![allow(
+)]
+#![deny(
+    const_err,
+    dead_code,
+    deprecated,
+    exceeding_bitshifts,
+    fat_ptr_transmutes,
+    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,
+    plugin_as_library,
+    private_no_mangle_fns,
+    private_no_mangle_statics,
+    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,
+    warnings,
+    while_true,
+)]
+
 extern crate data_encoding;
 #[macro_use]
 extern crate error_chain;
-extern crate itoa;
-extern crate dtoa;
 #[macro_use]
 extern crate serde;
 extern crate url;
@@ -84,3 +133,4 @@ pub use de::{QsDeserializer, from_bytes, from_reader, from_str};
 pub use de::Config;
 #[doc(inline)]
 pub use ser::{QsSerializer, to_string};
+
diff --git a/src/ser.rs b/src/ser.rs
index 3c6539d..1d5fe07 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -67,7 +67,8 @@ impl<'a, Target: 'a + UrlEncodedTarget> QsSerializer<'a, Target> {
 
     fn write_value(&mut self, value: &str) -> Result<()> {
         if let Some(ref key) = self.key {
-            self.urlencoder.append_pair(key, value);
+            // returns &Self back anyway
+            let _ = self.urlencoder.append_pair(key, value);
             Ok(())
         } else {
             Err(Error::no_key())