Add a not_found() helper for typical usage of NotFound

Some direct usage exists so the NotFound type is also re-exported.

Author: jtgeibel

src/github.rs

@@ -8,7 +8,7 @@ use serde::de::DeserializeOwned;
 use std::str;
 
 use crate::app::App;
-use crate::util::errors::{cargo_err, internal, AppError, AppResult, NotFound};
+use crate::util::errors::{cargo_err, internal, not_found, AppError, AppResult};
 
 /// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
 /// because custom error-code handling may be desirable. Use
@@ -46,7 +46,7 @@ fn handle_error_response(app: &App, error: &reqwest::Error) -> Box<dyn AppError>
              https://{}/login",
             app.config.domain_name,
         )),
-        Some(Status::NOT_FOUND) => Box::new(NotFound),
+        Some(Status::NOT_FOUND) => not_found(),
         _ => internal(&format_args!(
             "didn't get a 200 result from github: {}",
             error

src/router.rs

@@ -178,7 +178,7 @@ impl Handler for R404 {
                 req.mut_extensions().insert(m.params.clone());
                 m.handler.call(req)
             }
-            Err(..) => Ok(NotFound.response().unwrap()),
+            Err(..) => Ok(NotFound.into()),
         }
     }
 }
@@ -187,7 +187,7 @@ impl Handler for R404 {
 mod tests {
     use super::*;
     use crate::util::errors::{
-        bad_request, cargo_err, forbidden, internal, AppError, ChainError, NotFound,
+        bad_request, cargo_err, forbidden, internal, not_found, AppError, ChainError,
     };
     use crate::util::EndpointResult;
 
@@ -220,7 +220,7 @@ mod tests {
             StatusCode::NOT_FOUND
         );
         assert_eq!(
-            C(|_| err(NotFound)).call(&mut req).unwrap().status(),
+            C(|_| Err(not_found())).call(&mut req).unwrap().status(),
             StatusCode::NOT_FOUND
         );
 

src/util/errors.rs

@@ -25,6 +25,8 @@ use crate::util::{json_response, AppResponse};
 pub(super) mod concrete;
 mod http;
 
+pub(crate) use self::http::NotFound;
+
 /// Returns an error with status 200 and the provided description as JSON
 ///
 /// This is for backwards compatibility with cargo endpoints.  For all other
@@ -48,6 +50,10 @@ pub fn forbidden() -> Box<dyn AppError> {
     Box::new(http::Forbidden)
 }
 
+pub fn not_found() -> Box<dyn AppError> {
+    Box::new(http::NotFound)
+}
+
 /// Returns an error with status 500 and the provided description as JSON
 pub fn server_error<S: ToString + ?Sized>(error: &S) -> Box<dyn AppError> {
     Box::new(http::ServerError(error.to_string()))
@@ -103,7 +109,7 @@ impl dyn AppError {
 
     fn try_convert(err: &(dyn Error + Send + 'static)) -> Option<Box<Self>> {
         match err.downcast_ref() {
-            Some(DieselError::NotFound) => Some(Box::new(NotFound)),
+            Some(DieselError::NotFound) => Some(not_found()),
             Some(DieselError::DatabaseError(_, info))
                 if info.message().ends_with("read-only transaction") =>
             {
@@ -221,29 +227,6 @@ impl AppError for InternalAppError {
     }
 }
 
-// TODO: The remaining can probably move under `http`
-
-#[derive(Debug, Clone, Copy)]
-pub struct NotFound;
-
-impl From<NotFound> for AppResponse {
-    fn from(_: NotFound) -> AppResponse {
-        json_error("Not Found", StatusCode::NOT_FOUND)
-    }
-}
-
-impl AppError for NotFound {
-    fn response(&self) -> Option<AppResponse> {
-        Some(NotFound.into())
-    }
-}
-
-impl fmt::Display for NotFound {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "Not Found".fmt(f)
-    }
-}
-
 pub fn internal<S: ToString + ?Sized>(error: &S) -> Box<dyn AppError> {
     Box::new(InternalAppError {
         description: error.to_string(),

src/util/errors/http.rs

@@ -8,9 +8,29 @@ use conduit::StatusCode;
 // The following structs are emtpy and do not provide a custom message to the user
 
 #[derive(Debug)]
-pub(super) struct Forbidden;
+pub(crate) struct NotFound;
+
+// This struct has this helper impl for use as `NotFound.into()`
+impl From<NotFound> for AppResponse {
+    fn from(_: NotFound) -> AppResponse {
+        json_error("Not Found", StatusCode::NOT_FOUND)
+    }
+}
+
+impl AppError for NotFound {
+    fn response(&self) -> Option<AppResponse> {
+        Some(Self.into())
+    }
+}
+
+impl fmt::Display for NotFound {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "Not Found".fmt(f)
+    }
+}
+
 #[derive(Debug)]
-pub struct NotFound;
+pub(super) struct Forbidden;
 
 impl AppError for Forbidden {
     fn response(&self) -> Option<AppResponse> {