Various Clippy Fixes

src/cookies/middleware.rs

@@ -25,7 +25,7 @@ use std::sync::{Arc, RwLock};
 pub(crate) struct CookiesMiddleware;
 
 impl CookiesMiddleware {
- /// Creates a new CookiesMiddleware.
+ /// Creates a new `CookiesMiddleware`.
  pub fn new() -> Self {
  Self::default()
  }
@@ -82,15 +82,15 @@ impl CookieData {
  if let Some(cookie_headers) = req.header(&headers::COOKIE) {
  for cookie_header in cookie_headers {
  // spec says there should be only one, so this is permissive
- for pair in cookie_header.as_str().split(";") {
+ for pair in cookie_header.as_str().split(';') {
  if let Ok(cookie) = Cookie::parse_encoded(String::from(pair)) {
  jar.add_original(cookie);
  }
  }
  }
  }
 
- CookieData {
+ Self {
  content: Arc::new(RwLock::new(jar)),
  }
  }

src/endpoint.rs

@@ -27,10 +27,8 @@ use crate::{Middleware, Request, Response};
 /// Ok(String::from("hello"))
 /// }
 ///
-/// fn main() {
-/// let mut app = tide::Server::new();
-/// app.at("/hello").get(hello);
-/// }
+/// let mut app = tide::Server::new();
+/// app.at("/hello").get(hello);
 /// ```
 ///
 /// An endpoint with similar functionality that does not make use of the `async` keyword would look something like this:
@@ -41,10 +39,8 @@ use crate::{Middleware, Request, Response};
 /// async_std::future::ready(Ok(String::from("hello")))
 /// }
 ///
-/// fn main() {
-/// let mut app = tide::Server::new();
-/// app.at("/hello").get(hello);
-/// }
+/// let mut app = tide::Server::new();
+/// app.at("/hello").get(hello);
 /// ```
 ///
 /// Tide routes will also accept endpoints with `Fn` signatures of this form, but using the `async` keyword has better ergonomics.

src/fs/serve_dir.rs

@@ -57,12 +57,11 @@ impl<State> Endpoint<State> for ServeDir {
  Ok(file) => file,
  };
 
- let len = match file.metadata().await {
- Ok(metadata) => metadata.len() as usize,
- Err(_) => {
- log::warn!("Could not retrieve metadata");
- return Ok(Response::new(StatusCode::InternalServerError));
- }
+ let len = if let Ok(metadata) = file.metadata().await {
+ metadata.len() as usize
+ } else {
+ log::warn!("Could not retrieve metadata");
+ return Ok(Response::new(StatusCode::InternalServerError));
  };
 
  let body = Body::from_reader(BufReader::new(file), Some(len));

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

@@ -12,13 +12,14 @@ use crate::{Middleware, Next, Request};
 /// let mut app = tide::Server::new();
 /// app.middleware(tide::log::LogMiddleware::new());
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct LogMiddleware {
  _priv: (),
 }
 
 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

@@ -32,8 +32,8 @@ impl<State> Request<State> {
  state: Arc<State>,
  request: http_types::Request,
  route_params: Vec<Params>,
- ) -> Request<State> {
- Request {
+ ) -> Self {
+ Self {
  state,
  request,
  route_params,
@@ -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
@@ -171,8 +177,7 @@ impl<State> Request<State> {
  self.route_params
  .iter()
  .rev()
- .filter_map(|params| params.find(key))
- .next()
+ .find_map(|params| params.find(key))
  .unwrap()
  .parse()
  }
@@ -293,6 +298,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,9 +309,15 @@ impl<State> Request<State> {
  }
 
  /// Get the length of the body.
+ #[must_use]
  pub fn len(&self) -> Option<usize> {
  self.request.len()
  }
+ /// Checks if the body is empty.
+ #[must_use]
+ pub fn is_empty(&self) -> Option<bool> {
+ Some(self.request.len()? == 0)
+ }
 }
 
 impl<State> AsMut<http::Request> for Request<State> {

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,32 @@ 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()
  }
 
+ /// Checks if the body is empty.
+ #[must_use]
+ pub fn is_empty(&self) -> Option<bool> {
+ Some(self.res.len()? == 0)
+ }
+
  /// Get an HTTP header.
+ #[must_use]
  pub fn header(&self, name: &HeaderName) -> Option<&Vec<HeaderValue>> {
  self.res.header(name)
  }
@@ -126,6 +137,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 +147,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)
@@ -167,7 +180,7 @@ impl Response {
  pub async fn body_form<T: serde::Serialize>(
  mut self,
  form: T,
- ) -> Result<Response, serde_qs::Error> {
+ ) -> Result<Self, serde_qs::Error> {
  // TODO: think about how to handle errors
  self.res.set_body(serde_qs::to_string(&form)?.into_bytes());
  Ok(self
@@ -221,6 +234,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/router.rs

@@ -22,8 +22,8 @@ pub(crate) struct Selection<'a, State> {
 }
 
 impl<State: 'static> Router<State> {
- pub(crate) fn new() -> Router<State> {
- Router {
+ pub(crate) fn new() -> Self {
+ Self {
  method_map: HashMap::default(),
  all_method_router: MethodRouter::new(),
  }