move low level utils to separate crate

ntex-service/Cargo.toml

@@ -16,6 +16,7 @@ name = "ntex_service"
 path = "src/lib.rs"
 
 [dependencies]
+ntex-util = "0.1.0"
 pin-project-lite = "0.2.4"
 
 [dev-dependencies]

ntex-service/src/and_then.rs

@@ -271,8 +271,8 @@ where
 mod tests {
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::util::{lazy, Ready};
     use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory};
+    use ntex_util::future::{lazy, Ready};
 
     struct Srv1(Rc<Cell<usize>>);
 

ntex-service/src/and_then_apply_fn.rs

@@ -292,8 +292,8 @@ where
 mod tests {
     use super::*;
 
-    use crate::util::{lazy, Ready};
     use crate::{fn_service, pipeline, pipeline_factory, Service, ServiceFactory};
+    use ntex_util::future::{lazy, Ready};
 
     #[derive(Clone)]
     struct Srv;

ntex-service/src/apply.rs

@@ -211,12 +211,11 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_util::future::{lazy, Ready};
     use std::task::{Context, Poll};
 
     use super::*;
-    use crate::{
-        pipeline, pipeline_factory, util::lazy, util::Ready, Service, ServiceFactory,
-    };
+    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;

ntex-service/src/apply_cfg.rs

@@ -227,10 +227,11 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_util::future::Ready;
     use std::{cell::Cell, rc::Rc};
 
     use super::*;
-    use crate::{fn_service, util::Ready, Service};
+    use crate::{fn_service, Service};
 
     #[ntex::test]
     async fn test_apply() {

ntex-service/src/either.rs

@@ -1,147 +0,0 @@
-use std::{error, fmt, future::Future, pin::Pin, task::Context, task::Poll};
-
-/// Combines two different futures, streams, or sinks having the same associated types into a single
-/// type.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub enum Either<A, B> {
-    /// First branch of the type
-    Left(/* #[pin] */ A),
-    /// Second branch of the type
-    Right(/* #[pin] */ B),
-}
-
-impl<A, B> Either<A, B> {
-    fn project(self: Pin<&mut Self>) -> Either<Pin<&mut A>, Pin<&mut B>> {
-        unsafe {
-            match self.get_unchecked_mut() {
-                Either::Left(a) => Either::Left(Pin::new_unchecked(a)),
-                Either::Right(b) => Either::Right(Pin::new_unchecked(b)),
-            }
-        }
-    }
-
-    #[inline]
-    /// Return true if the value is the `Left` variant.
-    pub fn is_left(&self) -> bool {
-        match *self {
-            Either::Left(_) => true,
-            Either::Right(_) => false,
-        }
-    }
-
-    #[inline]
-    /// Return true if the value is the `Right` variant.
-    pub fn is_right(&self) -> bool {
-        !self.is_left()
-    }
-
-    #[inline]
-    /// Convert the left side of `Either<L, R>` to an `Option<L>`.
-    pub fn left(self) -> Option<A> {
-        match self {
-            Either::Left(l) => Some(l),
-            Either::Right(_) => None,
-        }
-    }
-
-    #[inline]
-    /// Convert the right side of `Either<L, R>` to an `Option<R>`.
-    pub fn right(self) -> Option<B> {
-        match self {
-            Either::Left(_) => None,
-            Either::Right(r) => Some(r),
-        }
-    }
-
-    #[inline]
-    /// Convert `&Either<L, R>` to `Either<&L, &R>`.
-    pub fn as_ref(&self) -> Either<&A, &B> {
-        match *self {
-            Either::Left(ref inner) => Either::Left(inner),
-            Either::Right(ref inner) => Either::Right(inner),
-        }
-    }
-
-    #[inline]
-    /// Convert `&mut Either<L, R>` to `Either<&mut L, &mut R>`.
-    pub fn as_mut(&mut self) -> Either<&mut A, &mut B> {
-        match *self {
-            Either::Left(ref mut inner) => Either::Left(inner),
-            Either::Right(ref mut inner) => Either::Right(inner),
-        }
-    }
-}
-
-impl<A, B, T> Either<(T, A), (T, B)> {
-    #[inline]
-    /// Factor out a homogeneous type from an either of pairs.
-    ///
-    /// Here, the homogeneous type is the first element of the pairs.
-    pub fn factor_first(self) -> (T, Either<A, B>) {
-        match self {
-            Either::Left((x, a)) => (x, Either::Left(a)),
-            Either::Right((x, b)) => (x, Either::Right(b)),
-        }
-    }
-}
-
-impl<A, B, T> Either<(A, T), (B, T)> {
-    #[inline]
-    /// Factor out a homogeneous type from an either of pairs.
-    ///
-    /// Here, the homogeneous type is the second element of the pairs.
-    pub fn factor_second(self) -> (Either<A, B>, T) {
-        match self {
-            Either::Left((a, x)) => (Either::Left(a), x),
-            Either::Right((b, x)) => (Either::Right(b), x),
-        }
-    }
-}
-
-impl<T> Either<T, T> {
-    #[inline]
-    /// Extract the value of an either over two equivalent types.
-    pub fn into_inner(self) -> T {
-        match self {
-            Either::Left(x) => x,
-            Either::Right(x) => x,
-        }
-    }
-}
-
-/// `Either` implements `Error` if *both* `A` and `B` implement it.
-impl<A, B> error::Error for Either<A, B>
-where
-    A: error::Error,
-    B: error::Error,
-{
-}
-
-impl<A, B> fmt::Display for Either<A, B>
-where
-    A: fmt::Display,
-    B: fmt::Display,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Either::Left(a) => a.fmt(f),
-            Either::Right(b) => b.fmt(f),
-        }
-    }
-}
-
-impl<A, B> Future for Either<A, B>
-where
-    A: Future,
-    B: Future<Output = A::Output>,
-{
-    type Output = A::Output;
-
-    #[inline]
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.project() {
-            Either::Left(x) => x.poll(cx),
-            Either::Right(x) => x.poll(cx),
-        }
-    }
-}

ntex-service/src/fn_service.rs

@@ -1,7 +1,9 @@
 use std::task::{Context, Poll};
 use std::{cell::Cell, cell::RefCell, future::Future, marker::PhantomData};
 
-use crate::{util::Ready, IntoService, IntoServiceFactory, Service, ServiceFactory};
+use ntex_util::future::Ready;
+
+use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 #[inline]
 /// Create `ServiceFactory` for function that can act as a `Service`
@@ -523,10 +525,11 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_util::future::lazy;
     use std::{rc::Rc, task::Poll};
 
     use super::*;
-    use crate::{util::lazy, Service, ServiceFactory};
+    use crate::{Service, ServiceFactory};
 
     #[ntex::test]
     async fn test_fn_service() {

ntex-service/src/fn_transform.rs

@@ -1,6 +1,7 @@
+use ntex_util::future::Ready;
 use std::{future::Future, marker::PhantomData};
 
-use crate::{apply_fn, dev::Apply, util::Ready, Service, Transform};
+use crate::{apply_fn, dev::Apply, Service, Transform};
 
 /// Use function as transform service
 pub fn fn_transform<S, F, R, Req, Res, Err>(
@@ -67,10 +68,11 @@ where
 #[cfg(test)]
 #[allow(clippy::redundant_clone)]
 mod tests {
+    use ntex_util::future::lazy;
     use std::task::{Context, Poll};
 
     use super::*;
-    use crate::{util::lazy, Service};
+    use crate::Service;
 
     #[derive(Clone)]
     struct Srv;

ntex-service/src/lazy.rs

@@ -1,32 +0,0 @@
-use std::{future::Future, pin::Pin, task::Context, task::Poll};
-
-/// Future for the [`lazy`] function.
-#[derive(Debug)]
-#[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct Lazy<F> {
-    f: Option<F>,
-}
-
-// safe because we never generate `Pin<&mut F>`
-impl<F> Unpin for Lazy<F> {}
-
-/// Creates a new future that allows delayed execution of a closure.
-///
-/// The provided closure is only run once the future is polled.
-pub fn lazy<F, R>(f: F) -> Lazy<F>
-where
-    F: FnOnce(&mut Context<'_>) -> R,
-{
-    Lazy { f: Some(f) }
-}
-
-impl<F, R> Future for Lazy<F>
-where
-    F: FnOnce(&mut Context<'_>) -> R,
-{
-    type Output = R;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<R> {
-        Poll::Ready((self.f.take().expect("Lazy polled after completion"))(cx))
-    }
-}

ntex-service/src/lib.rs

@@ -21,10 +21,6 @@ mod then;
 mod transform;
 mod transform_err;
 
-mod either;
-mod lazy;
-mod ready;
-
 pub use self::apply::{apply_fn, apply_fn_factory};
 pub use self::fn_service::{
     fn_factory, fn_factory_with_config, fn_mut_service, fn_service,
@@ -341,12 +337,6 @@ where
     tp.into_service()
 }
 
-pub mod util {
-    pub use crate::either::Either;
-    pub use crate::lazy::{lazy, Lazy};
-    pub use crate::ready::Ready;
-}
-
 pub mod dev {
     pub use crate::apply::{Apply, ApplyServiceFactory};
     pub use crate::fn_service::{

ntex-service/src/map.rs

@@ -206,8 +206,10 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_util::future::{lazy, Ready};
+
     use super::*;
-    use crate::{util::lazy, util::Ready, IntoServiceFactory, Service, ServiceFactory};
+    use crate::{IntoServiceFactory, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;

ntex-service/src/map_config.rs

@@ -304,10 +304,11 @@ where
 #[cfg(test)]
 #[allow(clippy::redundant_closure)]
 mod tests {
+    use ntex_util::future::Ready;
     use std::{cell::Cell, rc::Rc};
 
     use super::*;
-    use crate::{fn_factory_with_config, fn_service, util::Ready, ServiceFactory};
+    use crate::{fn_factory_with_config, fn_service, ServiceFactory};
 
     #[ntex::test]
     async fn test_map_config() {

ntex-service/src/map_err.rs

@@ -208,8 +208,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::util::{lazy, Ready};
     use crate::{IntoServiceFactory, Service, ServiceFactory};
+    use ntex_util::future::{lazy, Ready};
 
     #[derive(Clone)]
     struct Srv;

ntex-service/src/ready.rs

@@ -1,41 +0,0 @@
-//! Definition of the `Ready` (immediately finished) future
-use std::{future::Future, pin::Pin, task::Context, task::Poll};
-
-/// A future representing a value that is immediately ready.
-///
-/// Created by the `result` function.
-#[derive(Debug, Clone)]
-#[must_use = "futures do nothing unless polled"]
-pub enum Ready<T, E> {
-    Ok(T),
-    Err(E),
-    Done(Sealed),
-}
-
-#[derive(Debug, Clone)]
-pub struct Sealed;
-
-impl<T, E> Unpin for Ready<T, E> {}
-
-impl<T, E> Future for Ready<T, E> {
-    type Output = Result<T, E>;
-
-    #[inline]
-    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
-        let result = std::mem::replace(self.get_mut(), Ready::Done(Sealed));
-        match result {
-            Ready::Ok(ok) => Poll::Ready(Ok(ok)),
-            Ready::Err(err) => Poll::Ready(Err(err)),
-            Ready::Done(_) => panic!("cannot poll completed Ready future"),
-        }
-    }
-}
-
-impl<T, E> From<Result<T, E>> for Ready<T, E> {
-    fn from(r: Result<T, E>) -> Self {
-        match r {
-            Ok(v) => Ready::Ok(v),
-            Err(e) => Ready::Err(e),
-        }
-    }
-}

ntex-service/src/then.rs

@@ -256,11 +256,10 @@ where
 
 #[cfg(test)]
 mod tests {
+    use ntex_util::future::{lazy, Ready};
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::{
-        pipeline, pipeline_factory, util::lazy, util::Ready, Service, ServiceFactory,
-    };
+    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);

ntex-service/src/transform.rs

@@ -233,8 +233,10 @@ where
 #[cfg(test)]
 #[allow(clippy::redundant_clone)]
 mod tests {
+    use ntex_util::future::{lazy, Ready};
+
     use super::*;
-    use crate::{fn_service, util::lazy, util::Ready, Service, ServiceFactory};
+    use crate::{fn_service, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Tr;