Rename Ctx to ServiceCtx

ntex-service/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.2.0-beta.1] - 2023-06-19
+
+* Rename Ctx to ServiceCtx
+
 ## [1.2.0-beta.0] - 2023-06-16
 
 * Enforce service readiness during call

ntex-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "1.2.0-beta.0"
+version = "1.2.0-beta.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]

ntex-service/src/and_then.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
@@ -59,7 +59,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         AndThenServiceResponse {
             slf: self,
             state: State::A {
@@ -93,7 +93,7 @@ pin_project_lite::pin_project! {
         B: Service<A::Response, Error = A::Error>,
         B: 'f,
     {
-        A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<Ctx<'f, AndThen<A, B>>> },
+        A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<ServiceCtx<'f, AndThen<A, B>>> },
         B { #[pin] fut: ServiceCall<'f, B, A::Response> },
         Empty,
     }
@@ -234,7 +234,9 @@ where
 mod tests {
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::{fn_factory, pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{
+        fn_factory, pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory,
+    };
     use ntex_util::future::{lazy, Ready};
 
     #[derive(Clone)]
@@ -250,7 +252,11 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(
+            &'a self,
+            req: &'static str,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok(req)
         }
     }
@@ -268,7 +274,11 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(
+            &'a self,
+            req: &'static str,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok((req, "srv2"))
         }
     }

ntex-service/src/apply.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::type_complexity)]
 use std::{future::Future, marker, pin::Pin, rc::Rc, task, task::Poll};
 
-use super::ctx::{Ctx, ServiceCall, Waiters};
+use super::ctx::{ServiceCall, ServiceCtx, Waiters};
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform function to a service.
@@ -83,7 +83,7 @@ impl<S> ApplyService<S> {
     where
         S: Service<R>,
     {
-        Ctx::<S>::new(&self.waiters).call(&self.svc, req)
+        ServiceCtx::<S>::new(&self.waiters).call(&self.svc, req)
     }
 }
 
@@ -101,7 +101,7 @@ where
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: In, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: In, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         let svc = ApplyService {
             svc: self.service.clone(),
             waiters: ctx.waiters().clone(),
@@ -221,7 +221,7 @@ mod tests {
     use std::task::Poll;
 
     use super::*;
-    use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
@@ -231,7 +231,7 @@ mod tests {
         type Error = ();
         type Future<'f> = Ready<(), ()>;
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }

ntex-service/src/boxed.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use crate::ctx::{Ctx, Waiters};
+use crate::ctx::{ServiceCtx, Waiters};
 
 pub type BoxFuture<'a, I, E> = Pin<Box<dyn Future<Output = Result<I, E>> + 'a>>;
 
@@ -71,7 +71,7 @@ where
         req: Req,
         waiters: &'a Waiters,
     ) -> BoxFuture<'a, Self::Response, Self::Error> {
-        Box::pin(Ctx::<'a, S>::new(waiters).call_nowait(self, req))
+        Box::pin(ServiceCtx::<'a, S>::new(waiters).call_nowait(self, req))
     }
 }
 
@@ -131,7 +131,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         self.0.call(req, ctx.waiters())
     }
 }

ntex-service/src/ctx.rs

@@ -12,7 +12,7 @@ pub struct Container<S> {
     waiters: Waiters,
 }
 
-pub struct Ctx<'a, S: ?Sized> {
+pub struct ServiceCtx<'a, S: ?Sized> {
     waiters: &'a Waiters,
     _t: marker::PhantomData<Rc<S>>,
 }
@@ -103,7 +103,7 @@ impl<S> Container<S> {
     where
         S: Service<R>,
     {
-        let ctx = Ctx::<'a, S> {
+        let ctx = ServiceCtx::<'a, S> {
             waiters: &self.waiters,
             _t: marker::PhantomData,
         };
@@ -151,7 +151,7 @@ impl<S> ops::Deref for Container<S> {
     }
 }
 
-impl<'a, S: ?Sized> Ctx<'a, S> {
+impl<'a, S: ?Sized> ServiceCtx<'a, S> {
     pub(crate) fn new(waiters: &'a Waiters) -> Self {
         Self {
             waiters,
@@ -171,7 +171,7 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
     {
         svc.call(
             req,
-            Ctx {
+            ServiceCtx {
                 waiters: self.waiters,
                 _t: marker::PhantomData,
             },
@@ -195,9 +195,9 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
     }
 }
 
-impl<'a, S: ?Sized> Copy for Ctx<'a, S> {}
+impl<'a, S: ?Sized> Copy for ServiceCtx<'a, S> {}
 
-impl<'a, S: ?Sized> Clone for Ctx<'a, S> {
+impl<'a, S: ?Sized> Clone for ServiceCtx<'a, S> {
     #[inline]
     fn clone(&self) -> Self {
         Self {
@@ -256,7 +256,7 @@ where
 
                         let fut = svc.call(
                             req.take().unwrap(),
-                            Ctx {
+                            ServiceCtx {
                                 waiters,
                                 _t: marker::PhantomData,
                             },
@@ -327,7 +327,11 @@ mod tests {
             self.1.poll_ready(cx).map(|_| Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(
+            &'a self,
+            req: &'static str,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok(req)
         }
     }

ntex-service/src/fn_service.rs

@@ -1,6 +1,6 @@
 use std::{future::ready, future::Future, future::Ready, marker::PhantomData};
 
-use crate::{Ctx, IntoService, IntoServiceFactory, Service, ServiceFactory};
+use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 
 #[inline]
 /// Create `ServiceFactory` for function that can act as a `Service`
@@ -128,7 +128,7 @@ where
     type Future<'f> = Fut where Self: 'f, Req: 'f;
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         (self.f)(req)
     }
 }
@@ -190,7 +190,7 @@ where
     type Future<'f> = Fut where Self: 'f;
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         (self.f)(req)
     }
 }

ntex-service/src/fn_shutdown.rs

@@ -3,7 +3,7 @@ use std::future::{ready, Ready};
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
-use crate::{Ctx, Service};
+use crate::{Service, ServiceCtx};
 
 #[inline]
 /// Create `FnShutdown` for function that can act as a `on_shutdown` callback.
@@ -60,7 +60,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ready(Ok(req))
     }
 }

ntex-service/src/lib.rs

@@ -22,7 +22,7 @@ mod pipeline;
 mod then;
 
 pub use self::apply::{apply_fn, apply_fn_factory};
-pub use self::ctx::{Container, ContainerFactory, Ctx, ServiceCall};
+pub use self::ctx::{Container, ContainerFactory, ServiceCall, ServiceCtx};
 pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
 pub use self::fn_shutdown::fn_shutdown;
 pub use self::map_config::{map_config, unit_config};
@@ -59,7 +59,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 /// # use std::future::Future;
 /// # use std::pin::Pin;
 /// #
-/// # use ntex_service::{Ctx, Service};
+/// # use ntex_service::{Service, ServiceCtx};
 ///
 /// struct MyService;
 ///
@@ -68,7 +68,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 ///     type Error = Infallible;
 ///     type Future<'f> = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
 ///
-///     fn call<'a>(&'a self, req: u8, _: Ctx<'a, Self>) -> Self::Future<'a> {
+///     fn call<'a>(&'a self, req: u8, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
 ///         Box::pin(std::future::ready(Ok(req as u64)))
 ///     }
 /// }
@@ -103,7 +103,7 @@ pub trait Service<Req> {
     /// should take care to not call `poll_ready`. Caller of the service verifies readiness,
     /// Only way to make a `call` is to use `ctx` argument, it enforces readiness before calling
     /// service.
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>;
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>;
 
     #[inline]
     /// Returns `Ready` when the service is able to process requests.
@@ -261,7 +261,7 @@ where
     }
 
     #[inline]
-    fn call<'s>(&'s self, request: Req, ctx: Ctx<'s, Self>) -> S::Future<'s> {
+    fn call<'s>(&'s self, request: Req, ctx: ServiceCtx<'s, Self>) -> S::Future<'s> {
         ctx.call_nowait(&**self, request)
     }
 }
@@ -285,7 +285,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, request: Req, ctx: Ctx<'a, Self>) -> S::Future<'a> {
+    fn call<'a>(&'a self, request: Req, ctx: ServiceCtx<'a, Self>) -> S::Future<'a> {
         ctx.call_nowait(&**self, request)
     }
 }

ntex-service/src/map.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
@@ -54,7 +54,7 @@ where
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         MapFuture {
             fut: ctx.call(&self.service, req),
             slf: self,
@@ -192,7 +192,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
 
     use super::*;
-    use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
+    use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
@@ -206,7 +206,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }

ntex-service/src/map_err.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `map_err` combinator, changing the type of a service's
 /// error.
@@ -57,7 +57,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         MapErrFuture {
             slf: self,
             fut: ctx.call(&self.service, req),
@@ -196,7 +196,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
 
     use super::*;
-    use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
+    use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv(bool);
@@ -214,7 +214,7 @@ mod tests {
             }
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Err(())
         }
     }

ntex-service/src/middleware.rs

@@ -214,7 +214,7 @@ mod tests {
     use std::marker;
 
     use super::*;
-    use crate::{fn_service, Container, Ctx, Service, ServiceCall, ServiceFactory};
+    use crate::{fn_service, Container, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Tr<R>(marker::PhantomData<R>);
@@ -239,7 +239,7 @@ mod tests {
             self.0.poll_ready(cx)
         }
 
-        fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             ctx.call(&self.0, req)
         }
     }

ntex-service/src/pipeline.rs

@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use crate::and_then::{AndThen, AndThenFactory};
-use crate::ctx::{Container, Ctx, ServiceCall};
+use crate::ctx::{Container, ServiceCall, ServiceCtx};
 use crate::map::{Map, MapFactory};
 use crate::map_err::{MapErr, MapErrFactory};
 use crate::map_init_err::MapInitErr;
@@ -144,7 +144,7 @@ impl<Req, Svc: Service<Req>> Service<Req> for Pipeline<Req, Svc> {
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ctx.call(&self.service, req)
     }
 }

ntex-service/src/then.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
@@ -60,7 +60,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ThenServiceResponse {
             slf: self,
             state: State::A {
@@ -95,7 +95,7 @@ pin_project_lite::pin_project! {
         B: 'f,
         R: 'f,
     {
-        A { #[pin] fut: ServiceCall<'f, A, R>, ctx: Ctx<'f, Then<A, B>> },
+        A { #[pin] fut: ServiceCall<'f, A, R>, ctx: ServiceCtx<'f, Then<A, B>> },
         B { #[pin] fut: ServiceCall<'f, B, Result<A::Response, A::Error>> },
         Empty,
     }
@@ -248,7 +248,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
@@ -266,7 +266,7 @@ mod tests {
         fn call<'a>(
             &'a self,
             req: Result<&'static str, &'static str>,
-            _: Ctx<'a, Self>,
+            _: ServiceCtx<'a, Self>,
         ) -> Self::Future<'a> {
             match req {
                 Ok(msg) => Ready::Ok(msg),
@@ -291,7 +291,7 @@ mod tests {
         fn call<'a>(
             &'a self,
             req: Result<&'static str, ()>,
-            _: Ctx<'a, Self>,
+            _: ServiceCtx<'a, Self>,
         ) -> Self::Future<'a> {
             match req {
                 Ok(msg) => Ready::Ok((msg, "ok")),