From a4c389b80debd94c74e268e7ccba1d1b28d32e41 Mon Sep 17 00:00:00 2001
From: fakeshadow <24548779@qq.com>
Date: Mon, 4 Jan 2021 20:31:56 +0800
Subject: [PATCH] rename to compat

---
 CHANGES.md                              |  2 +-
 src/middleware/{scoped.rs => compat.rs} | 42 +++++++++++--------------
 src/middleware/condition.rs             |  2 +-
 src/middleware/mod.rs                   |  4 +--
 4 files changed, 23 insertions(+), 27 deletions(-)
 rename src/middleware/{scoped.rs => compat.rs} (83%)

diff --git a/CHANGES.md b/CHANGES.md
index 0688e7fca..0077cd518 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,7 +2,7 @@
 
 ## Unreleased - 2021-xx-xx
 ### Added
-* `Scoped` middleware enabling generic response body/error type of middlewares
+* `Compat` middleware enabling generic response body/error type of middlewares
   like `Logger` and `Compress` to be used in `middleware::Condition` 
   and `Resource`, `Scope` services. [#1865]
 
diff --git a/src/middleware/scoped.rs b/src/middleware/compat.rs
similarity index 83%
rename from src/middleware/scoped.rs
rename to src/middleware/compat.rs
index aa9318769..66346b6d6 100644
--- a/src/middleware/scoped.rs
+++ b/src/middleware/compat.rs
@@ -18,30 +18,28 @@ use crate::service::ServiceResponse;
 /// ## Usage
 ///
 /// ```rust
-/// use actix_web::middleware::{Logger, Scoped};
+/// use actix_web::middleware::{Logger, Compat};
 /// use actix_web::{App, web};
 ///
-/// # fn main() {
 /// let logger = Logger::default();
 ///
 /// // this would not compile
 /// // let app = App::new().service(web::scope("scoped").wrap(logger));
 ///
 /// // by using scoped middleware we can use logger in scope.
-/// let app = App::new().service(web::scope("scoped").wrap(Scoped::new(logger)));
-/// # }
+/// let app = App::new().service(web::scope("scoped").wrap(Compat::new(logger)));
 /// ```
-pub struct Scoped<T> {
+pub struct Compat<T> {
     transform: T,
 }
 
-impl<T> Scoped<T> {
+impl<T> Compat<T> {
     pub fn new(transform: T) -> Self {
         Self { transform }
     }
 }
 
-impl<S, T, Req> Transform<S, Req> for Scoped<T>
+impl<S, T, Req> Transform<S, Req> for Compat<T>
 where
     S: Service<Req>,
     T: Transform<S, Req>,
@@ -51,7 +49,7 @@ where
 {
     type Response = ServiceResponse;
     type Error = Error;
-    type Transform = ScopedMiddleware<T::Transform>;
+    type Transform = CompatMiddleware<T::Transform>;
     type InitError = T::InitError;
     type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>;
 
@@ -59,16 +57,16 @@ where
         let fut = self.transform.new_transform(service);
         Box::pin(async move {
             let service = fut.await?;
-            Ok(ScopedMiddleware { service })
+            Ok(CompatMiddleware { service })
         })
     }
 }
 
-pub struct ScopedMiddleware<S> {
+pub struct CompatMiddleware<S> {
     service: S,
 }
 
-impl<S, Req> Service<Req> for ScopedMiddleware<S>
+impl<S, Req> Service<Req> for CompatMiddleware<S>
 where
     S: Service<Req>,
     S::Response: MapServiceResponseBody,
@@ -76,7 +74,7 @@ where
 {
     type Response = ServiceResponse;
     type Error = Error;
-    type Future = ScopedFuture<S::Future>;
+    type Future = CompatMiddlewareFuture<S::Future>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(cx).map_err(From::from)
@@ -84,18 +82,17 @@ where
 
     fn call(&mut self, req: Req) -> Self::Future {
         let fut = self.service.call(req);
-        ScopedFuture { fut }
+        CompatMiddlewareFuture { fut }
     }
 }
 
-#[doc(hidden)]
 #[pin_project::pin_project]
-pub struct ScopedFuture<Fut> {
+pub struct CompatMiddlewareFuture<Fut> {
     #[pin]
     fut: Fut,
 }
 
-impl<Fut, T, E> Future for ScopedFuture<Fut>
+impl<Fut, T, E> Future for CompatMiddlewareFuture<Fut>
 where
     Fut: Future<Output = Result<T, E>>,
     T: MapServiceResponseBody,
@@ -109,9 +106,8 @@ where
     }
 }
 
-// private trait for convert ServiceResponse's ResponseBody<B> generic type
+// trait for convert ServiceResponse's ResponseBody<B> generic type
 // to ResponseBody<Body>
-#[doc(hidden)]
 pub trait MapServiceResponseBody {
     fn map_body(self) -> ServiceResponse;
 }
@@ -142,8 +138,8 @@ mod tests {
         let mut srv = init_service(
             App::new().service(
                 web::scope("app")
-                    .wrap(Scoped::new(logger))
-                    .wrap(Scoped::new(compress))
+                    .wrap(Compat::new(logger))
+                    .wrap(Compat::new(compress))
                     .service(
                         web::resource("/test").route(web::get().to(HttpResponse::Ok)),
                     ),
@@ -164,8 +160,8 @@ mod tests {
         let mut srv = init_service(
             App::new().service(
                 web::resource("app/test")
-                    .wrap(Scoped::new(logger))
-                    .wrap(Scoped::new(compress))
+                    .wrap(Compat::new(logger))
+                    .wrap(Compat::new(compress))
                     .route(web::get().to(HttpResponse::Ok)),
             ),
         )
@@ -186,7 +182,7 @@ mod tests {
 
         let logger = Logger::default();
 
-        let mut mw = Condition::new(true, Scoped::new(logger))
+        let mut mw = Condition::new(true, Compat::new(logger))
             .new_transform(srv.into_service())
             .await
             .unwrap();
diff --git a/src/middleware/condition.rs b/src/middleware/condition.rs
index 068b3ffa1..04173e053 100644
--- a/src/middleware/condition.rs
+++ b/src/middleware/condition.rs
@@ -8,7 +8,7 @@ use futures_util::future::{ok, Either, FutureExt, LocalBoxFuture};
 /// The controlled middleware must not change the `Service` interfaces.
 ///
 /// This means you cannot control such middlewares like `Logger` or `Compress` directly.
-/// *. See `Scoped` middleware for alternative.
+/// *. See `Compat` middleware for alternative.
 ///
 /// ## Usage
 ///
diff --git a/src/middleware/mod.rs b/src/middleware/mod.rs
index c7aa026a9..af44fd8c7 100644
--- a/src/middleware/mod.rs
+++ b/src/middleware/mod.rs
@@ -5,15 +5,15 @@ mod compress;
 #[cfg(feature = "compress")]
 pub use self::compress::Compress;
 
+mod compat;
 mod condition;
 mod defaultheaders;
 pub mod errhandlers;
 mod logger;
 pub mod normalize;
-mod scoped;
 
+pub use self::compat::Compat;
 pub use self::condition::Condition;
 pub use self::defaultheaders::DefaultHeaders;
 pub use self::logger::Logger;
 pub use self::normalize::NormalizePath;
-pub use self::scoped::Scoped;