clippy::must_use_candidate

Author: eopb

src/lib.rs

@@ -227,6 +227,7 @@ pub use http_types::{self as http, Body, Error, Status, StatusCode};
 /// #
 /// # Ok(()) }) }
 /// ```
+#[must_use]
 pub fn new() -> server::Server<()> {
     Server::new()
 }

src/log/middleware.rs

@@ -19,6 +19,7 @@ pub struct LogMiddleware {
 
 impl LogMiddleware {
     /// Create a new instance of `LogMiddleware`.
+    #[must_use]
     pub fn new() -> Self {
         Self { _priv: () }
     }

src/middleware.rs

@@ -47,6 +47,7 @@ pub struct Next<'a, State> {
 
 impl<'a, State: 'static> Next<'a, State> {
     /// Asynchronously execute the remaining middleware chain.
+    #[must_use]
     pub fn run(mut self, req: Request<State>) -> BoxFuture<'a, crate::Result> {
         if let Some((current, next)) = self.next_middleware.split_first() {
             self.next_middleware = next;

src/request.rs

@@ -59,6 +59,7 @@ impl<State> Request<State> {
     /// #
     /// # Ok(()) })}
     /// ```
+    #[must_use]
     pub fn method(&self) -> Method {
         self.request.method()
     }
@@ -82,6 +83,7 @@ impl<State> Request<State> {
     /// #
     /// # Ok(()) })}
     /// ```
+    #[must_use]
     pub fn uri(&self) -> &Url {
         self.request.url()
     }
@@ -105,6 +107,7 @@ impl<State> Request<State> {
     /// #
     /// # Ok(()) })}
     /// ```
+    #[must_use]
     pub fn version(&self) -> Option<Version> {
         self.request.version()
     }
@@ -128,6 +131,7 @@ impl<State> Request<State> {
     /// #
     /// # Ok(()) })}
     /// ```
+    #[must_use]
     pub fn header(
         &self,
         key: &http_types::headers::HeaderName,
@@ -136,6 +140,7 @@ impl<State> Request<State> {
     }
 
     /// Get a local value.
+    #[must_use]
     pub fn local<T: Send + Sync + 'static>(&self) -> Option<&T> {
         self.request.local().get()
     }
@@ -146,6 +151,7 @@ impl<State> Request<State> {
         self
     }
 
+    #[must_use]
     ///  Access app-global state.
     pub fn state(&self) -> &State {
         &self.state
@@ -293,6 +299,7 @@ impl<State> Request<State> {
     }
 
     /// returns a `Cookie` by name of the cookie.
+    #[must_use]
     pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
         let cookie_data = self
             .local::<CookieData>()
@@ -303,6 +310,7 @@ impl<State> Request<State> {
     }
 
     /// Get the length of the body.
+    #[must_use]
     pub fn len(&self) -> Option<usize> {
         self.request.len()
     }

src/response.rs

@@ -25,6 +25,7 @@ pub struct Response {
 
 impl Response {
     /// Create a new instance.
+    #[must_use]
     pub fn new(status: StatusCode) -> Self {
         let res = http_types::Response::new(status);
         Self {
@@ -72,22 +73,26 @@ impl Response {
     }
 
     /// Returns the statuscode.
+    #[must_use]
     pub fn status(&self) -> crate::StatusCode {
         self.res.status()
     }
 
     /// Set the statuscode.
+    #[must_use]
     pub fn set_status(mut self, status: crate::StatusCode) -> Self {
         self.res.set_status(status);
         self
     }
 
     /// Get the length of the body.
+    #[must_use]
     pub fn len(&self) -> Option<usize> {
         self.res.len()
     }
 
     /// Get an HTTP header.
+    #[must_use]
     pub fn header(&self, name: &HeaderName) -> Option<&Vec<HeaderValue>> {
         self.res.header(name)
     }
@@ -126,6 +131,7 @@ impl Response {
     /// Set the request MIME.
     ///
     /// [Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types)
+    #[must_use]
     pub fn set_mime(self, mime: Mime) -> Self {
         self.set_header(http_types::headers::CONTENT_TYPE, format!("{}", mime))
     }
@@ -135,6 +141,7 @@ impl Response {
     /// # Mime
     ///
     /// The encoding is set to `text/plain; charset=utf-8`.
+    #[must_use]
     pub fn body_string(mut self, string: String) -> Self {
         self.res.set_body(string);
         self.set_mime(mime::TEXT_PLAIN_UTF_8)
@@ -221,6 +228,7 @@ impl Response {
     }
 
     /// Get a local value.
+    #[must_use]
     pub fn local<T: Send + Sync + 'static>(&self) -> Option<&T> {
         self.res.local().get()
     }

src/route.rs

@@ -60,6 +60,7 @@ impl<'a, State: 'static> Route<'a, State> {
     }
 
     /// Get the current path.
+    #[must_use]
     pub fn path(&self) -> &str {
         &self.path
     }

src/security/cors.rs

@@ -14,7 +14,7 @@ use crate::{Request, Result};
 /// use http_types::headers::HeaderValue;
 /// use tide::security::{CorsMiddleware, Origin};
 ///
-/// CorsMiddleware::new()
+/// let cors = CorsMiddleware::new()
 ///     .allow_methods("GET, POST, OPTIONS".parse::<HeaderValue>().unwrap())
 ///     .allow_origin(Origin::from("*"))
 ///     .allow_credentials(false);
@@ -35,6 +35,7 @@ pub const WILDCARD: &str = "*";
 
 impl CorsMiddleware {
     /// Creates a new Cors middleware.
+    #[must_use]
     pub fn new() -> Self {
         Self {
             allow_credentials: None,
@@ -47,6 +48,7 @@ impl CorsMiddleware {
     }
 
     /// Set allow_credentials and return new Cors
+    #[must_use]
     pub fn allow_credentials(mut self, allow_credentials: bool) -> Self {
         self.allow_credentials = match allow_credentials.to_string().parse() {
             Ok(header) => Some(header),

src/server.rs

@@ -150,6 +150,7 @@ impl Server<()> {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn new() -> Server<()> {
         Self::with_state(())
     }