refactor: stricter rustc linting

Author: Fishrock123

src/buffer.rs

@@ -1,6 +1,7 @@
 use crate::constants;
 use bytes::{Bytes, BytesMut};
 use futures::stream::Stream;
+use std::fmt;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -26,7 +27,7 @@ impl StreamBuffer {
         }
     }
 
-    pub fn poll_stream(&mut self, cx: &mut Context) -> Result<(), crate::Error> {
+    pub fn poll_stream(&mut self, cx: &mut Context<'_>) -> Result<(), crate::Error> {
         if self.eof {
             return Ok(());
         }
@@ -151,3 +152,9 @@ impl StreamBuffer {
         self.buf.split_to(self.buf.len()).freeze()
     }
 }
+
+impl fmt::Debug for StreamBuffer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StreamBuffer").finish()
+    }
+}

src/constraints.rs

@@ -42,6 +42,7 @@ use crate::size_limit::SizeLimit;
 /// # }
 /// # tokio::runtime::Runtime::new().unwrap().block_on(run());
 /// ```
+#[derive(Debug)]
 pub struct Constraints {
     pub(crate) size_limit: SizeLimit,
     pub(crate) allowed_fields: Option<Vec<String>>,

src/content_disposition.rs

@@ -1,6 +1,7 @@
 use crate::constants;
 use http::header::{self, HeaderMap};
 
+#[derive(Debug)]
 pub(crate) struct ContentDisposition {
     pub(crate) field_name: Option<String>,
     pub(crate) file_name: Option<String>,

src/field.rs

@@ -48,13 +48,15 @@ use std::task::{Context, Poll};
 /// then the parent [`Multipart`](./struct.Multipart.html) will never be able to yield the next field in the stream.
 /// The task waiting on the [`Multipart`](./struct.Multipart.html) will also never be notified, which, depending on the executor implementation,
 /// may cause a deadlock.
+#[derive(Debug)]
 pub struct Field {
     state: Arc<Mutex<MultipartState>>,
     headers: HeaderMap,
     done: bool,
     meta: FieldMeta,
 }
 
+#[derive(Debug)]
 struct FieldMeta {
     content_disposition: ContentDisposition,
     content_type: Option<mime::Mime>,
@@ -228,7 +230,7 @@ impl Field {
     /// let stream = once(async move { Result::<Bytes, Infallible>::Ok(Bytes::from(data)) });
     /// let mut multipart = Multipart::new(stream, "X-BOUNDARY");
     ///
-    /// while let Some(mut field) = multipart.next_field().await.unwrap() {
+    /// while let Some(field) = multipart.next_field().await.unwrap() {
     ///    let content = field.text().await.unwrap();
     ///    assert_eq!(content, "abcd");
     /// }
@@ -258,7 +260,7 @@ impl Field {
     /// let stream = once(async move { Result::<Bytes, Infallible>::Ok(Bytes::from(data)) });
     /// let mut multipart = Multipart::new(stream, "X-BOUNDARY");
     ///
-    /// while let Some(mut field) = multipart.next_field().await.unwrap() {
+    /// while let Some(field) = multipart.next_field().await.unwrap() {
     ///    let content = field.text_with_charset("utf-8").await.unwrap();
     ///    assert_eq!(content, "abcd");
     /// }
@@ -314,7 +316,7 @@ impl Field {
 impl Stream for Field {
     type Item = Result<Bytes, crate::Error>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         if self.done {
             return Poll::Ready(None);
         }

src/helpers.rs

@@ -2,7 +2,7 @@ use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use httparse::Header;
 use std::convert::TryFrom;
 
-pub(crate) fn convert_raw_headers_to_header_map(raw_headers: &[Header]) -> crate::Result<HeaderMap> {
+pub(crate) fn convert_raw_headers_to_header_map(raw_headers: &[Header<'_>]) -> crate::Result<HeaderMap> {
     let mut headers = HeaderMap::with_capacity(raw_headers.len());
 
     for raw_header in raw_headers {

src/lib.rs

@@ -99,6 +99,16 @@
 //!
 //! For more examples, please visit [examples](https://github.com/rousan/multer-rs/tree/master/examples).
 
+#![forbid(unsafe_code, future_incompatible)]
+#![warn(
+    missing_debug_implementations,
+    rust_2018_idioms,
+    trivial_casts,
+    unused_qualifications
+)]
+#![doc(test(attr(deny(rust_2018_idioms, warnings))))]
+#![doc(test(attr(allow(unused_extern_crates, unused_variables))))]
+
 pub use constraints::Constraints;
 pub use error::Error;
 pub use field::Field;
@@ -131,7 +141,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// # }
 /// # run();
 /// ```
-pub fn parse_boundary<T: AsRef<str>>(content_type: T) -> crate::Result<String> {
+pub fn parse_boundary<T: AsRef<str>>(content_type: T) -> Result<String> {
     let m = content_type
         .as_ref()
         .parse::<mime::Mime>()

src/multipart.rs

@@ -46,6 +46,7 @@ use tokio_util::codec::{BytesCodec, FramedRead};
 /// # }
 /// # tokio::runtime::Runtime::new().unwrap().block_on(run());
 /// ```
+#[derive(Debug)]
 pub struct Multipart {
     state: Arc<Mutex<MultipartState>>,
     constraints: Constraints,
@@ -202,12 +203,13 @@ impl Multipart {
     /// # Examples
     ///
     /// ```
+    /// # #[cfg(feature = "reader")]
+    /// # {
     /// use multer::Multipart;
     /// use bytes::Bytes;
     /// use std::convert::Infallible;
     /// use futures::stream::once;
     ///
-    /// # #[cfg(feature = "reader")]
     /// # async fn run() {
     /// let data = "--X-BOUNDARY\r\nContent-Disposition: form-data; name=\"my_text_field\"\r\n\r\nabcd\r\n--X-BOUNDARY--\r\n";
     /// let reader = data.as_bytes();
@@ -217,8 +219,8 @@ impl Multipart {
     ///     println!("Index: {:?}, Content: {:?}", idx, field.text().await)
     /// }
     /// # }
-    /// # #[cfg(feature = "reader")]
     /// # tokio::runtime::Runtime::new().unwrap().block_on(run());
+    /// # }
     /// ```
     pub async fn next_field_with_idx(&mut self) -> crate::Result<Option<(usize, Field)>> {
         self.try_next().await.map(|f| f.map(|field| (field.index(), field)))
@@ -228,7 +230,7 @@ impl Multipart {
 impl Stream for Multipart {
     type Item = Result<Field, crate::Error>;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let mut mutex_guard = match self.state.lock() {
             Ok(lock) => lock,
             Err(err) => {

src/size_limit.rs

@@ -4,6 +4,7 @@ use std::collections::HashMap;
 /// Represents size limit of the stream to prevent DoS attacks.
 ///
 /// Please refer [`Constraints`](./struct.Constraints.html) for more info.
+#[derive(Debug)]
 pub struct SizeLimit {
     pub(crate) whole_stream: u64,
     pub(crate) per_field: u64,

src/state.rs

@@ -1,6 +1,7 @@
 use crate::buffer::StreamBuffer;
 use std::task::Waker;
 
+#[derive(Debug)]
 pub(crate) struct MultipartState {
     pub(crate) buffer: StreamBuffer,
     pub(crate) boundary: String,