hide private items

Author: seqre

cot-core/src/body.rs

@@ -33,10 +33,10 @@ use crate::{Error, Result};
 /// ```
 #[derive(Debug)]
 pub struct Body {
-    pub inner: BodyInner,
+    pub(crate) inner: BodyInner,
 }
 
-pub enum BodyInner {
+pub(crate) enum BodyInner {
     Fixed(Bytes),
     Streaming(SyncWrapper<Pin<Box<dyn Stream<Item = Result<Bytes>> + Send>>>),
     Axum(SyncWrapper<axum::body::Body>),
@@ -171,12 +171,13 @@ impl Body {
     }
 
     #[must_use]
+    #[doc(hidden)]
     pub fn axum(inner: axum::body::Body) -> Self {
         Self::new(BodyInner::Axum(SyncWrapper::new(inner)))
     }
 
     #[must_use]
-    pub fn wrapper(inner: BoxBody<Bytes, Error>) -> Self {
+    pub(crate) fn wrapper(inner: BoxBody<Bytes, Error>) -> Self {
         Self::new(BodyInner::Wrapper(inner))
     }
 }

cot-core/src/error.rs

@@ -7,10 +7,8 @@
 pub mod backtrace;
 pub(crate) mod error_impl;
 mod method_not_allowed;
-mod not_found;
 mod uncaught_panic;
 
 pub use error_impl::{Error, impl_into_cot_error};
 pub use method_not_allowed::MethodNotAllowed;
-pub use not_found::{Kind as NotFoundKind, NotFound};
 pub use uncaught_panic::UncaughtPanic;

cot-core/src/error/error_impl.rs

@@ -8,7 +8,6 @@ use crate::StatusCode;
 // Need to rename Backtrace to CotBacktrace, because otherwise it triggers special behavior
 // in the thiserror library
 use crate::error::backtrace::{__cot_create_backtrace, Backtrace as CotBacktrace};
-use crate::error::not_found::NotFound;
 
 /// An error that can occur while using Cot.
 pub struct Error {
@@ -151,46 +150,6 @@ impl Error {
         Self::internal(error)
     }
 
-    /// Create a new "404 Not Found" error without a message.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use cot::Error;
-    ///
-    /// let error = Error::not_found();
-    /// ```
-    #[must_use]
-    #[deprecated(
-        note = "Use `cot::Error::from(cot::error::NotFound::new())` instead",
-        since = "0.4.0"
-    )]
-    pub fn not_found() -> Self {
-        Self::from(NotFound::new())
-    }
-
-    /// Create a new "404 Not Found" error with a message.
-    ///
-    /// Note that the message is only displayed when Cot's debug mode is
-    /// enabled. It will not be exposed to the user in production.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use cot::Error;
-    ///
-    /// let id = 123;
-    /// let error = Error::not_found_message(format!("User with id={id} not found"));
-    /// ```
-    #[must_use]
-    #[deprecated(
-        note = "Use `cot::Error::from(cot::error::NotFound::with_message())` instead",
-        since = "0.4.0"
-    )]
-    pub fn not_found_message(message: String) -> Self {
-        Self::from(NotFound::with_message(message))
-    }
-
     /// Returns the HTTP status code associated with this error.
     ///
     /// This method returns the appropriate HTTP status code that should be
@@ -216,6 +175,7 @@ impl Error {
     }
 
     #[must_use]
+    #[doc(hidden)]
     pub fn backtrace(&self) -> &CotBacktrace {
         &self.repr.backtrace
     }

cot-core/src/lib.rs

@@ -21,7 +21,7 @@ pub mod middleware;
 pub mod request;
 pub mod response;
 
-pub use body::{Body, BodyInner};
+pub use body::Body;
 pub use error::Error;
 
 /// A type alias for an HTTP status code.

cot-core/src/response/into_response.rs

@@ -388,10 +388,10 @@ impl IntoResponse for Body {
 #[cfg(test)]
 mod tests {
     use bytes::{Bytes, BytesMut};
-    use http::{self, HeaderMap, HeaderValue};
+    use http::{self, HeaderMap, HeaderValue, Method};
 
     use super::*;
-    use crate::error::NotFound;
+    use crate::error::MethodNotAllowed;
     use crate::html::Html;
     use crate::response::Response;
     use crate::{Body, StatusCode};
@@ -421,13 +421,13 @@ mod tests {
 
     #[cot::test]
     async fn test_result_err_into_response() {
-        let err = Error::from(NotFound::with_message("test"));
+        let err = Error::from(MethodNotAllowed::new(Method::POST));
         let res: Result<&'static str, Error> = Err(err);
 
         let error_result = res.into_response();
 
         assert!(error_result.is_err());
-        assert!(error_result.err().unwrap().to_string().contains("test"));
+        assert!(error_result.err().unwrap().to_string().contains("POST"));
     }
 
     #[cot::test]

cot/src/error.rs

@@ -5,8 +5,10 @@
 //! including 404 Not Found errors, uncaught panics, and custom error pages.
 
 pub mod handler;
+mod not_found;
 
 #[doc(inline)]
-pub use cot_core::error::{MethodNotAllowed, NotFound, NotFoundKind, UncaughtPanic};
+pub use cot_core::error::{MethodNotAllowed, UncaughtPanic};
 #[doc(inline)]
 pub(crate) use cot_core::error::{backtrace, impl_into_cot_error};
+pub use not_found::{Kind as NotFoundKind, NotFound};

cot-core/src/error/not_found.rs cot/src/error/not_found.rscot-core/src/error/not_found.rs renamed to cot/src/error/not_found.rs

@@ -2,7 +2,7 @@
 
 use thiserror::Error;
 
-use crate::error::error_impl::impl_into_cot_error;
+use crate::error::impl_into_cot_error;
 
 #[expect(clippy::doc_link_with_quotes, reason = "404 Not Found link")]
 /// A ["404 Not Found"] error that can be returned by Cot applications.
@@ -72,7 +72,7 @@ impl NotFound {
     }
 
     #[must_use]
-    pub fn router() -> Self {
+    pub(crate) fn router() -> Self {
         Self::with_kind(Kind::FromRouter)
     }
 

cot/src/error_page.rs

@@ -72,10 +72,10 @@ impl ErrorPageTemplateBuilder {
         if let Some(not_found) = error.inner().downcast_ref::<NotFound>() {
             use crate::error::NotFoundKind as Kind;
             match &not_found.kind {
-                Kind::Custom { .. } => {
+                Kind::Custom => {
                     Self::build_error_data(&mut error_data, error);
                 }
-                Kind::WithMessage { 0: message, .. } => {
+                Kind::WithMessage(message) => {
                     Self::build_error_data(&mut error_data, error);
                     error_message = Some(message.clone());
                 }