Fix formatting issues

Author: the10thWiz

core/http/Cargo.toml

@@ -36,7 +36,7 @@ memchr = "2"
 stable-pattern = "0.1"
 cookie = { version = "0.18", features = ["percent-encode"] }
 state = "0.6"
-transient = { version = "0.4", path = "/home/matthew/transient" }
+transient = { version = "0.4", path = "/code/matthew/transient" }
 
 [dependencies.serde]
 version = "1.0"

core/lib/Cargo.toml

@@ -74,7 +74,7 @@ tokio-stream = { version = "0.1.6", features = ["signal", "time"] }
 cookie = { version = "0.18", features = ["percent-encode"] }
 futures = { version = "0.3.30", default-features = false, features = ["std"] }
 state = "0.6"
-transient = { version = "0.4", features = ["either"], path = "/home/matthew/transient" }
+transient = { version = "0.4", features = ["either"], path = "/code/matthew/transient" }
 
 # tracing
 tracing = { version = "0.1.40", default-features = false, features = ["std", "attributes"] }

core/lib/src/catcher/catcher.rs

@@ -322,7 +322,9 @@ impl Catcher {
 
 impl Default for Catcher {
     fn default() -> Self {
-        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: Option<&(dyn TypedError<'r> + 'r)>) -> BoxFuture<'r> {
+        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: Option<&'r dyn TypedError<'r>>)
+            -> BoxFuture<'r>
+        {
             Box::pin(async move { Ok(default_handler(s, req)) })
         }
 
@@ -342,7 +344,8 @@ pub struct StaticInfo {
     /// The catcher's error type.
     pub error_type: Option<(TypeId, &'static str)>,
     /// The catcher's handler, i.e, the annotated function.
-    pub handler: for<'r> fn(Status, &'r Request<'_>, Option<&'r (dyn TypedError<'r> + 'r)>) -> BoxFuture<'r>,
+    pub handler: for<'r> fn(Status, &'r Request<'_>, Option<&'r dyn TypedError<'r>>)
+            -> BoxFuture<'r>,
     /// The file, line, and column where the catcher was defined.
     pub location: (&'static str, u32, u32),
 }

core/lib/src/catcher/handler.rs

@@ -100,13 +100,17 @@ pub trait Handler: Cloneable + Send + Sync + 'static {
     /// Nevertheless, failure is allowed, both for convenience and necessity. If
     /// an error handler fails, Rocket's default `500` catcher is invoked. If it
     /// succeeds, the returned `Response` is used to respond to the client.
-    async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, error: Option<&'r (dyn TypedError<'r> + 'r)>)
-        -> Result<'r>;
+    async fn handle<'r>(
+        &self,
+        status: Status,
+        req: &'r Request<'_>,
+        error: Option<&'r dyn TypedError<'r>>
+    ) -> Result<'r>;
 }
 
 // We write this manually to avoid double-boxing.
 impl<F: Clone + Sync + Send + 'static> Handler for F
-    where for<'x> F: Fn(Status, &'x Request<'_>, Option<&'x (dyn TypedError<'x> + 'x)>) -> BoxFuture<'x>,
+    where for<'x> F: Fn(Status, &'x Request<'_>, Option<&'x dyn TypedError<'x>>) -> BoxFuture<'x>,
 {
     fn handle<'r, 'life0, 'life1, 'life2, 'async_trait>(
         &'life0 self,
@@ -125,7 +129,9 @@ impl<F: Clone + Sync + Send + 'static> Handler for F
 
 // Used in tests! Do not use, please.
 #[doc(hidden)]
-pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>, _: Option<&(dyn TypedError<'r> + 'r)>) -> BoxFuture<'r> {
+pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>, _: Option<&'r dyn TypedError<'r>>)
+    -> BoxFuture<'r>
+{
    Box::pin(async move { Ok(Response::new()) })
 }
 

core/lib/src/catcher/types.rs

@@ -40,7 +40,7 @@ pub trait TypedError<'r>: AsAny<Inv<'r>> + Send + Sync + 'r {
     fn respond_to(&self, request: &'r Request<'_>) -> Result<Response<'r>, Status> {
         Err(Status::InternalServerError)
     }
-    
+
     /// A descriptive name of this error type. Defaults to the type name.
     fn name(&self) -> &'static str { std::any::type_name::<Self>() }
 
@@ -92,7 +92,7 @@ impl<'r, L, R> TypedError<'r> for Either<L, R>
 
     fn name(&self) -> &'static str { std::any::type_name::<Self>() }
 
-    fn source(&'r self) -> Option<&'r (dyn TypedError<'r> + 'r)> { 
+    fn source(&'r self) -> Option<&'r (dyn TypedError<'r> + 'r)> {
         match self {
             Self::Left(v) => Some(v),
             Self::Right(v) => Some(v),

core/lib/src/erased.rs

@@ -121,8 +121,10 @@ impl ErasedRequest {
             let parent: &'static ErasedRequest = unsafe { transmute(parent) };
             let rocket: &Rocket<Orbit> = &parent._rocket;
             let request: &Request<'_> = &parent.request;
-            // SAFETY: error_ptr is transmuted into the same type, with the same lifetime as the request.
-            // It is kept alive by the erased response, so that the response type can borrow from it
+            // SAFETY: TODO: error_ptr is transmuted into the same type, with the
+            // same lifetime as the request.
+            // It is kept alive by the erased response, so that the response
+            // type can borrow from it
             dispatch(token, rocket, request, data, unsafe { transmute(&mut error_ptr)}).await
         };
 

core/lib/src/lifecycle.rs

@@ -44,6 +44,11 @@ async fn catch_handle<Fut, T, F>(name: Option<&str>, run: F) -> Option<T>
         .ok()
 }
 
+pub(crate) fn error_ref<'r>(error_ptr: &'r mut Option<Box<dyn TypedError<'r> + 'r>>)
+    -> Option<&'r dyn TypedError<'r>> {
+    error_ptr.as_ref().map(|b| b.as_ref())
+}
+
 impl Rocket<Orbit> {
     /// Preprocess the request for Rocket things. Currently, this means:
     ///
@@ -112,21 +117,21 @@ impl Rocket<Orbit> {
                     Outcome::Success(response) => response,
                     Outcome::Error((status, error)) => {
                         *error_ptr = error;
-                        self.dispatch_error(status, request, error_ptr.as_ref().map(|b| b.as_ref())).await
+                        self.dispatch_error(status, request, error_ref(error_ptr)).await
                     },
                     Outcome::Forward((_, status, error)) => {
                         *error_ptr = error;
-                        self.dispatch_error(status, request, error_ptr.as_ref().map(|b| b.as_ref())).await
+                        self.dispatch_error(status, request, error_ref(error_ptr)).await
                     },
                 }
             }
             Outcome::Forward((_, status, error)) => {
                 *error_ptr = error;
-                self.dispatch_error(status, request, error_ptr.as_ref().map(|b| b.as_ref())).await
+                self.dispatch_error(status, request, error_ref(error_ptr)).await
             },
             Outcome::Error((status, error)) => {
                 *error_ptr = error;
-                self.dispatch_error(status, request, error_ptr.as_ref().map(|b| b.as_ref())).await
+                self.dispatch_error(status, request, error_ref(error_ptr)).await
             },
         };
 
@@ -289,7 +294,11 @@ impl Rocket<Orbit> {
         let mut counter = 0;
         // Matches error [.source ...] type
         while error_copy.is_some() && counter < 5 {
-            if let Some(catcher) = self.router.catch(status, req, error_copy.map(|e| e.trait_obj_typeid())) {
+            if let Some(catcher) = self.router.catch(
+                status,
+                req,
+                error_copy.map(|e| e.trait_obj_typeid())
+            ) {
                 return self.invoke_specific_catcher(catcher, status, error_copy, req).await;
             }
             error_copy = error_copy.and_then(|e| e.source());
@@ -303,7 +312,11 @@ impl Rocket<Orbit> {
         let mut counter = 0;
         // Matches error [.source ...] type, and any status
         while error_copy.is_some() && counter < 5 {
-            if let Some(catcher) = self.router.catch_any(status, req, error_copy.map(|e| e.trait_obj_typeid())) {
+            if let Some(catcher) = self.router.catch_any(
+                status,
+                req,
+                error_copy.map(|e| e.trait_obj_typeid())
+            ) {
                 return self.invoke_specific_catcher(catcher, status, error_copy, req).await;
             }
             error_copy = error_copy.and_then(|e| e.source());

core/lib/src/local/asynchronous/request.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 
+use crate::lifecycle::error_ref;
 use crate::request::RequestErrors;
 use crate::{Request, Data};
 use crate::http::{Status, Method};
@@ -89,7 +90,7 @@ impl<'c> LocalRequest<'c> {
                 return LocalResponse::new(self.request, move |req, error_ptr| {
                     // TODO: Ideally the RequestErrors should contain actual information.
                     *error_ptr = Some(Box::new(RequestErrors::new(&[])));
-                    rocket.dispatch_error(Status::BadRequest, req, error_ptr.as_ref().map(|b| b.as_ref()))
+                    rocket.dispatch_error(Status::BadRequest, req, error_ref(error_ptr))
                 }).await
             }
         }

core/lib/src/request/request.rs

@@ -16,8 +16,8 @@ use crate::request::{FromParam, FromSegments, FromRequest, Outcome, AtomicMethod
 use crate::form::{self, ValueField, FromForm};
 use crate::data::Limits;
 
-use crate::http::ProxyProto;
-use crate::http::{Method, Header, HeaderMap, ContentType, Accept, MediaType, CookieJar, Cookie, Status};
+use crate::http::{Method, Header, HeaderMap, ContentType, Accept, MediaType, CookieJar, Cookie,
+    ProxyProto, Status};
 use crate::http::uri::{fmt::Path, Origin, Segments, Host, Authority};
 use crate::listener::{Certificates, Endpoint};
 

core/lib/src/response/responder.rs

@@ -498,13 +498,15 @@ impl<'r, 'o: 'r, R: ?Sized + ToOwned> Responder<'r, 'o> for std::borrow::Cow<'o,
           <<&'o R as Responder<'r, 'o>>::Error as Transient>::Transience: CanTranscendTo<Inv<'r>>,
           <R as ToOwned>::Owned: Responder<'r, 'o> + 'r,
           <<R as ToOwned>::Owned as Responder<'r, 'o>>::Error: Transient,
-          <<<R as ToOwned>::Owned as Responder<'r, 'o>>::Error as Transient>::Transience: CanTranscendTo<Inv<'r>>,
+          <<<R as ToOwned>::Owned as Responder<'r, 'o>>::Error as Transient>::Transience:
+                                              CanTranscendTo<Inv<'r>>,
+                                              // TODO: this atrocious formatting
 {
     type Error = Either<
         <&'o R as Responder<'r, 'o>>::Error,
         <R::Owned as Responder<'r, 'o>>::Error,
     >;
-    
+
     fn respond_to(self, req: &'r Request<'_>) -> response::Outcome<'o, Self::Error> {
         match self {
             std::borrow::Cow::Borrowed(b) => b.respond_to(req).map_error(|e| Either::Left(e)),

core/lib/src/route/handler.rs

@@ -194,7 +194,10 @@ impl<'r, 'o: 'r> Outcome<'o> {
         match responder.respond_to(req) {
             response::Outcome::Success(response) => Outcome::Success(response),
             response::Outcome::Error(error) => {
-                crate::trace::info!(type_name = std::any::type_name_of_val(&error), "Typed error to catch");
+                crate::trace::info!(
+                    type_name = std::any::type_name_of_val(&error),
+                    "Typed error to catch"
+                );
                 Outcome::Error((error.status(), Some(Box::new(error))))
             },
             response::Outcome::Forward(status) => Outcome::Error((status, None)),

core/lib/src/router/router.rs

@@ -56,14 +56,18 @@ impl Router {
 
     // For many catchers, using aho-corasick or similar should be much faster.
     // TODO: document difference between catch, and catch_any
-    pub fn catch<'r>(&self, status: Status, req: &'r Request<'r>, error: Option<TypeId>) -> Option<&Catcher> {
+    pub fn catch<'r>(&self, status: Status, req: &'r Request<'r>, error: Option<TypeId>)
+        -> Option<&Catcher>
+    {
         // Note that catchers are presorted by descending base length.
         self.catchers.get(&Some(status.code))
             .and_then(|c| c.iter().find(|c| c.matches(status, req, error)))
     }
 
     // For many catchers, using aho-corasick or similar should be much faster.
-    pub fn catch_any<'r>(&self, status: Status, req: &'r Request<'r>, error: Option<TypeId>) -> Option<&Catcher> {
+    pub fn catch_any<'r>(&self, status: Status, req: &'r Request<'r>, error: Option<TypeId>)
+        -> Option<&Catcher>
+    {
         // Note that catchers are presorted by descending base length.
         self.catchers.get(&None)
             .and_then(|c| c.iter().find(|c| c.matches(status, req, error)))
@@ -556,7 +560,9 @@ mod test {
         router
     }
 
-    fn catcher<'a>(router: &'a Router, status: Status, uri: &str, error_ty: Option<TypeId>) -> Option<&'a Catcher> {
+    fn catcher<'a>(router: &'a Router, status: Status, uri: &str, error_ty: Option<TypeId>)
+        -> Option<&'a Catcher>
+    {
         let client = Client::debug_with(vec![]).expect("client");
         let request = client.get(Origin::parse(uri).unwrap());
         router.catch(status, &request, error_ty)

docs/guide/05-requests.md

@@ -2051,7 +2051,7 @@ on implementing [`Transient`] for custom error types.
 
 * The form::Errors type does not (yet) implement Transient
 
-The function arguement must be a reference to the error type expected. See the 
+The function arguement must be a reference to the error type expected. See the
 [error handling example](@git/master/examples/error-handling)
 for a full application, including the route that generates the error.
 

examples/error-handling/Cargo.toml

@@ -7,4 +7,4 @@ publish = false
 
 [dependencies]
 rocket = { path = "../../core/lib" }
-transient = { path = "/home/matthew/transient" }
+transient = { path = "/code/matthew/transient" }