make url optional; change Ready fut

ntex-service/src/fn_service.rs

@@ -323,7 +323,7 @@ where
         let f = self.f_shutdown.take();
         self.f_shutdown.set(f.clone());
 
-        Ready::ok(FnService {
+        Ready::Ok(FnService {
             f: self.f.clone(),
             f_shutdown: Cell::new(f),
             _t: PhantomData,

ntex-service/src/fn_transform.rs

@@ -49,7 +49,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(apply_fn(service, self.f.clone()))
+        Ready::Ok(apply_fn(service, self.f.clone()))
     }
 }
 

ntex-service/src/ready.rs

@@ -6,42 +6,36 @@ use std::{future::Future, pin::Pin, task::Context, task::Poll};
 /// Created by the `result` function.
 #[derive(Debug, Clone)]
 #[must_use = "futures do nothing unless polled"]
-pub struct Ready<T, E>(Option<Result<T, E>>);
-
-impl<T, E> Ready<T, E> {
-    #[inline]
-    /// Creates a new "leaf future" which will resolve with the given result.
-    pub fn result(r: Result<T, E>) -> Ready<T, E> {
-        Ready(Some(r))
-    }
-
-    #[inline]
-    /// Creates a "leaf future" from an immediate value of a finished and
-    /// successful computation.
-    pub fn ok(t: T) -> Ready<T, E> {
-        Self(Some(Ok(t)))
-    }
-
-    #[inline]
-    /// Creates a "leaf future" from an immediate value of a failed computation.
-    pub fn err(e: E) -> Ready<T, E> {
-        Self(Some(Err(e)))
-    }
+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(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
-        Poll::Ready(self.0.take().expect("cannot poll Ready future twice"))
+    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 {
-        Self::result(r)
+        match r {
+            Ok(v) => Ready::Ok(v),
+            Err(e) => Ready::Err(e),
+        }
     }
 }

ntex/CHANGES.md

@@ -10,6 +10,8 @@
 
 * reduce futures crate dependencies
 
+* make url crate optional
+
 ## [0.3.13] - 2021-03-26
 
 * framed: add socket disconnect notification

ntex/Cargo.toml

@@ -35,6 +35,9 @@ compress = ["flate2", "brotli2"]
 # enable cookie support
 cookie = ["coo-kie", "coo-kie/percent-encode"]
 
+# url support
+url = ["url-pkg"]
+
 [dependencies]
 ntex-codec = "0.4.1"
 ntex-rt = "0.2.2"
@@ -69,7 +72,7 @@ serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.7"
 socket2 = "0.4"
-url = "2.1"
+url-pkg = { version = "2.1", package = "url", optional = true }
 coo-kie = { version = "0.15", package = "cookie", optional = true }
 tokio = { version = "1", default-features=false, features = ["sync"] }
 

ntex/src/connect/openssl.rs

@@ -86,7 +86,7 @@ impl<T: Address + 'static> ServiceFactory for OpensslConnector<T> {
     type Future = Ready<Self::Service, Self::InitError>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(self.clone())
+        Ready::Ok(self.clone())
     }
 }
 

ntex/src/connect/resolve.rs

@@ -27,10 +27,10 @@ impl<T: Address> Resolver<T> {
         mut req: Connect<T>,
     ) -> impl Future<Output = Result<Connect<T>, ConnectError>> {
         if req.addr.is_some() || req.req.addr().is_some() {
-            Either::Right(Ready::ok(req))
+            Either::Right(Ready::Ok(req))
         } else if let Ok(ip) = req.host().parse() {
             req.addr = Some(Either::Left(net::SocketAddr::new(ip, req.port())));
-            Either::Right(Ready::ok(req))
+            Either::Right(Ready::Ok(req))
         } else {
             trace!("DNS resolver: resolving host {:?}", req.host());
 
@@ -112,7 +112,7 @@ impl<T: Address> ServiceFactory for Resolver<T> {
     type Future = Ready<Self::Service, Self::InitError>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(self.clone())
+        Ready::Ok(self.clone())
     }
 }
 

ntex/src/connect/rustls.rs

@@ -81,7 +81,7 @@ impl<T: Address + 'static> ServiceFactory for RustlsConnector<T> {
     type Future = Ready<Self::Service, Self::InitError>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(self.clone())
+        Ready::Ok(self.clone())
     }
 }
 

ntex/src/connect/service.rs

@@ -60,7 +60,7 @@ impl<T: Address> ServiceFactory for Connector<T> {
 
     #[inline]
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(self.clone())
+        Ready::Ok(self.clone())
     }
 }
 

ntex/src/http/body.rs

@@ -692,7 +692,7 @@ mod tests {
     #[crate::rt_test]
     async fn body_stream() {
         let st =
-            BodyStream::new(stream::once(Ready::<_, io::Error>::ok(Bytes::from("1"))));
+            BodyStream::new(stream::once(Ready::<_, io::Error>::Ok(Bytes::from("1"))));
         let body: Body = st.into();
         assert!(format!("{:?}", body).contains("Body::Message(_)"));
         assert!(body != Body::None);

ntex/src/http/client/connection.rs

@@ -170,7 +170,7 @@ where
                         None,
                     ));
                 }
-                Either::Right(Ready::err(SendRequestError::TunnelNotSupported))
+                Either::Right(Ready::Err(SendRequestError::TunnelNotSupported))
             }
         }
     }

ntex/src/http/client/connector.rs

@@ -342,7 +342,7 @@ where
                 if let Some(ref conn) = self.ssl_pool {
                     Either::Left(conn.call(req))
                 } else {
-                    Either::Right(Ready::err(ConnectError::SslIsNotSupported))
+                    Either::Right(Ready::Err(ConnectError::SslIsNotSupported))
                 }
             }
             _ => Either::Left(self.tcp_pool.call(req)),

ntex/src/http/client/ws.rs

@@ -468,15 +468,15 @@ where
             |req, srv| match req {
                 DispatchItem::Item(item) => Either::Left(srv.call(item)),
                 DispatchItem::WBackPressureEnabled
-                | DispatchItem::WBackPressureDisabled => Either::Right(Ready::ok(None)),
+                | DispatchItem::WBackPressureDisabled => Either::Right(Ready::Ok(None)),
                 DispatchItem::KeepAliveTimeout => {
-                    Either::Right(Ready::err(ws::WsError::KeepAlive))
+                    Either::Right(Ready::Err(ws::WsError::KeepAlive))
                 }
                 DispatchItem::DecoderError(e) | DispatchItem::EncoderError(e) => {
-                    Either::Right(Ready::err(ws::WsError::Protocol(e)))
+                    Either::Right(Ready::Err(ws::WsError::Protocol(e)))
                 }
                 DispatchItem::IoError(e) => {
-                    Either::Right(Ready::err(ws::WsError::Io(e)))
+                    Either::Right(Ready::Err(ws::WsError::Io(e)))
                 }
             },
         );

ntex/src/http/h1/expect.rs

@@ -17,7 +17,7 @@ impl ServiceFactory for ExpectHandler {
 
     #[inline]
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(ExpectHandler)
+        Ready::Ok(ExpectHandler)
     }
 }
 
@@ -34,6 +34,6 @@ impl Service for ExpectHandler {
 
     #[inline]
     fn call(&self, req: Request) -> Self::Future {
-        Ready::ok(req)
+        Ready::Ok(req)
     }
 }

ntex/src/server/config.rs

@@ -69,7 +69,7 @@ impl ServiceConfig {
     {
         self.apply_async::<_, Ready<(), &'static str>, &'static str>(move |mut rt| {
             f(&mut rt);
-            Ready::ok(())
+            Ready::Ok(())
         })
     }
 
@@ -166,7 +166,7 @@ impl InternalServiceFactory for ConfiguredService {
                         Box::new(StreamService::new(service::fn_service(
                             move |_: TcpStream| {
                                 error!("Service {:?} is not configured", name);
-                                Ready::<_, ()>::ok(())
+                                Ready::<_, ()>::Ok(())
                             },
                         ))),
                     ));

ntex/src/server/openssl.rs

@@ -64,7 +64,7 @@ where
 
     fn new_service(&self, _: ()) -> Self::Future {
         MAX_SSL_ACCEPT_COUNTER.with(|conns| {
-            Ready::ok(AcceptorService {
+            Ready::Ok(AcceptorService {
                 acceptor: self.acceptor.clone(),
                 conns: conns.priv_clone(),
                 timeout: self.timeout,

ntex/src/server/rustls.rs

@@ -65,7 +65,7 @@ impl<T: AsyncRead + AsyncWrite + Unpin> ServiceFactory for Acceptor<T> {
 
     fn new_service(&self, _: ()) -> Self::Future {
         MAX_SSL_ACCEPT_COUNTER.with(|conns| {
-            Ready::ok(AcceptorService {
+            Ready::Ok(AcceptorService {
                 acceptor: self.config.clone().into(),
                 conns: conns.priv_clone(),
                 timeout: self.timeout,

ntex/src/server/service.rs

@@ -92,12 +92,12 @@ where
                         let _ = f.await;
                         drop(guard);
                     });
-                    Ready::ok(())
+                    Ready::Ok(())
                 } else {
-                    Ready::err(())
+                    Ready::Err(())
                 }
             }
-            _ => Ready::ok(()),
+            _ => Ready::Ok(()),
         }
     }
 }

ntex/src/server/worker.rs

@@ -530,7 +530,7 @@ mod tests {
         fn new_service(&self, _: ()) -> Self::Future {
             let mut cnt = self.counter.lock().unwrap();
             *cnt += 1;
-            Ready::ok(Srv {
+            Ready::Ok(Srv {
                 st: self.st.clone(),
             })
         }
@@ -566,7 +566,7 @@ mod tests {
         }
 
         fn call(&self, _: TcpStream) -> Self::Future {
-            Ready::ok(())
+            Ready::Ok(())
         }
     }
 

ntex/src/util/buffer.rs

@@ -56,7 +56,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(BufferService {
+        Ready::Ok(BufferService {
             size: self.buf_size,
             inner: Rc::new(Inner {
                 service,
@@ -267,7 +267,7 @@ mod tests {
         fn call(&self, _: ()) -> Self::Future {
             self.0.ready.set(false);
             self.0.count.set(self.0.count.get() + 1);
-            Ready::ok(())
+            Ready::Ok(())
         }
     }
 

ntex/src/util/inflight.rs

@@ -36,7 +36,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(InFlightService::new(self.max_inflight, service))
+        Ready::Ok(InFlightService::new(self.max_inflight, service))
     }
 }
 

ntex/src/util/keepalive.rs

@@ -63,7 +63,7 @@ where
     type Future = Ready<Self::Service, Self::InitError>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(KeepAliveService::new(
+        Ready::Ok(KeepAliveService::new(
             self.ka,
             self.time.timer(),
             self.f.clone(),
@@ -133,7 +133,7 @@ where
 
     fn call(&self, req: R) -> Self::Future {
         self.inner.borrow_mut().expire = Instant::from_std(self.time.now() + self.ka);
-        Ready::ok(req)
+        Ready::Ok(req)
     }
 }
 

ntex/src/util/sink.rs

@@ -77,6 +77,6 @@ where
     }
 
     fn call(&self, req: I) -> Self::Future {
-        Ready::result(Pin::new(&mut *self.sink.borrow_mut()).start_send(req))
+        Ready::from(Pin::new(&mut *self.sink.borrow_mut()).start_send(req))
     }
 }

ntex/src/util/time.rs

@@ -51,7 +51,7 @@ impl ServiceFactory for LowResTime {
 
     #[inline]
     fn new_service(&self, _: ()) -> Self::Future {
-        Ready::ok(self.timer())
+        Ready::Ok(self.timer())
     }
 }
 
@@ -100,7 +100,7 @@ impl Service for LowResTimeService {
 
     #[inline]
     fn call(&self, _: ()) -> Self::Future {
-        Ready::ok(self.now())
+        Ready::Ok(self.now())
     }
 }
 

ntex/src/util/timeout.rs

@@ -93,7 +93,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(TimeoutService {
+        Ready::Ok(TimeoutService {
             service,
             timeout: self.timeout,
         })

ntex/src/util/variant.rs

@@ -343,7 +343,7 @@ mod tests {
         }
 
         fn call(&self, _: ()) -> Self::Future {
-            Ready::<_, ()>::ok(1)
+            Ready::<_, ()>::Ok(1)
         }
     }
 
@@ -365,7 +365,7 @@ mod tests {
         }
 
         fn call(&self, _: ()) -> Self::Future {
-            Ready::<_, ()>::ok(2)
+            Ready::<_, ()>::Ok(2)
         }
     }
 

ntex/src/web/app.rs

@@ -382,7 +382,7 @@ where
             pipeline_factory(filter).and_then_apply_fn(ep, move |result, srv| {
                 match result {
                     Either::Left(req) => Either::Left(srv.call(req)),
-                    Either::Right(res) => Either::Right(Ready::ok(res)),
+                    Either::Right(res) => Either::Right(Ready::Ok(res)),
                 }
             });
 

ntex/src/web/error.rs

@@ -6,7 +6,8 @@ use derive_more::{Display, From};
 
 pub use http::Error as HttpError;
 pub use serde_json::error::Error as JsonError;
-pub use url::ParseError as UrlParseError;
+#[cfg(feature = "url")]
+pub use url_pkg::ParseError as UrlParseError;
 
 use super::{HttpRequest, HttpResponse};
 use crate::http::body::Body;
@@ -94,6 +95,7 @@ pub enum UrlGenerationError {
     #[display(fmt = "Not all path pattern covered")]
     NotEnoughElements,
     /// URL parse error
+    #[cfg(feature = "url")]
     #[display(fmt = "{}", _0)]
     ParseError(UrlParseError),
 }

ntex/src/web/extract.rs

@@ -48,9 +48,9 @@ pub trait FromRequest<Err>: Sized {
 ///
 ///     fn from_request(req: &HttpRequest, payload: &mut http::Payload) -> Self::Future {
 ///         if rand::random() {
-///             Ready::ok(Thing { name: "thingy".into() })
+///             Ready::Ok(Thing { name: "thingy".into() })
 ///         } else {
-///             Ready::err(error::ErrorBadRequest("no luck").into())
+///             Ready::Err(error::ErrorBadRequest("no luck").into())
 ///         }
 ///     }
 /// }
@@ -118,9 +118,9 @@ where
 ///
 ///     fn from_request(req: &HttpRequest, payload: &mut http::Payload) -> Self::Future {
 ///         if rand::random() {
-///             Ready::ok(Thing { name: "thingy".into() })
+///             Ready::Ok(Thing { name: "thingy".into() })
 ///         } else {
-///             Ready::err(error::ErrorBadRequest("no luck").into())
+///             Ready::Err(error::ErrorBadRequest("no luck").into())
 ///         }
 ///     }
 /// }

ntex/src/web/httprequest.rs

@@ -7,7 +7,7 @@ use crate::router::Path;
 use crate::util::{Extensions, Ready};
 
 use super::config::AppConfig;
-use super::error::{ErrorRenderer, UrlGenerationError};
+use super::error::ErrorRenderer;
 use super::extract::FromRequest;
 use super::info::ConnectionInfo;
 use super::rmap::ResourceMap;
@@ -133,6 +133,7 @@ impl HttpRequest {
         self.head().extensions_mut()
     }
 
+    #[cfg(feature = "url")]
     /// Generate url for named resource
     ///
     /// ```rust
@@ -155,7 +156,7 @@ impl HttpRequest {
         &self,
         name: &str,
         elements: U,
-    ) -> Result<url::Url, UrlGenerationError>
+    ) -> Result<url_pkg::Url, super::error::UrlGenerationError>
     where
         U: IntoIterator<Item = I>,
         I: AsRef<str>,
@@ -163,11 +164,15 @@ impl HttpRequest {
         self.0.rmap.url_for(&self, name, elements)
     }
 
+    #[cfg(feature = "url")]
     /// Generate url for named resource
     ///
     /// This method is similar to `HttpRequest::url_for()` but it can be used
     /// for urls that do not contain variable parts.
-    pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenerationError> {
+    pub fn url_for_static(
+        &self,
+        name: &str,
+    ) -> Result<url_pkg::Url, super::error::UrlGenerationError> {
         const NO_PARAMS: [&str; 0] = [];
         self.url_for(name, &NO_PARAMS)
     }
@@ -391,6 +396,7 @@ mod tests {
         assert_eq!(req.query_string(), "id=test");
     }
 
+    #[cfg(feature = "url")]
     #[test]
     fn test_url_for() {
         let mut res = ResourceDef::new("/user/{name}.{ext}");
@@ -407,11 +413,11 @@ mod tests {
 
         assert_eq!(
             req.url_for("unknown", &["test"]),
-            Err(UrlGenerationError::ResourceNotFound)
+            Err(crate::web::error::UrlGenerationError::ResourceNotFound)
         );
         assert_eq!(
             req.url_for("index", &["test"]),
-            Err(UrlGenerationError::NotEnoughElements)
+            Err(crate::web::error::UrlGenerationError::NotEnoughElements)
         );
         let url = req.url_for("index", &["test", "html"]);
         assert_eq!(
@@ -420,6 +426,7 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "url")]
     #[test]
     fn test_url_for_static() {
         let mut rdef = ResourceDef::new("/index.html");
@@ -441,6 +448,7 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "url")]
     #[test]
     fn test_url_for_external() {
         let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");

ntex/src/web/middleware/compress.rs

@@ -59,7 +59,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(CompressMiddleware {
+        Ready::Ok(CompressMiddleware {
             service,
             encoding: self.enc,
             _t: marker::PhantomData,

ntex/src/web/middleware/defaultheaders.rs

@@ -100,7 +100,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(DefaultHeadersMiddleware {
+        Ready::Ok(DefaultHeadersMiddleware {
             service,
             inner: self.inner.clone(),
             _t: PhantomData,

ntex/src/web/middleware/logger.rs

@@ -127,7 +127,7 @@ where
     type Future = Ready<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        Ready::ok(LoggerMiddleware {
+        Ready::Ok(LoggerMiddleware {
             service,
             inner: self.inner.clone(),
         })

ntex/src/web/resource.rs

@@ -273,7 +273,7 @@ where
             pipeline_factory(filter).and_then_apply_fn(ep, move |result, srv| {
                 match result {
                     Either::Left(req) => Either::Left(srv.call(req)),
-                    Either::Right(res) => Either::Right(Ready::ok(res)),
+                    Either::Right(res) => Either::Right(Ready::Ok(res)),
                 }
             });
 
@@ -541,7 +541,7 @@ impl<Err: ErrorRenderer> Service for ResourceService<Err> {
         if let Some(ref default) = self.default {
             Either::Right(default.call(req))
         } else {
-            Either::Left(Ready::ok(WebResponse::new(
+            Either::Left(Ready::Ok(WebResponse::new(
                 Response::MethodNotAllowed().finish(),
                 req.into_parts().0,
             )))

ntex/src/web/rmap.rs

@@ -1,10 +1,11 @@
 use std::{cell::RefCell, rc::Rc};
 
-use url::Url;
+#[cfg(feature = "url")]
+use url_pkg::Url;
 
 use crate::router::ResourceDef;
 use crate::util::HashMap;
-use crate::web::error::UrlGenerationError;
+#[cfg(feature = "url")]
 use crate::web::httprequest::HttpRequest;
 
 #[derive(Clone, Debug)]
@@ -44,6 +45,7 @@ impl ResourceMap {
     }
 }
 
+#[cfg(feature = "url")]
 impl ResourceMap {
     /// Generate url for named resource
     ///
@@ -54,7 +56,7 @@ impl ResourceMap {
         req: &HttpRequest,
         name: &str,
         elements: U,
-    ) -> Result<Url, UrlGenerationError>
+    ) -> Result<Url, super::error::UrlGenerationError>
     where
         U: IntoIterator<Item = I>,
         I: AsRef<str>,
@@ -75,7 +77,7 @@ impl ResourceMap {
                 Ok(Url::parse(&path)?)
             }
         } else {
-            Err(UrlGenerationError::ResourceNotFound)
+            Err(super::error::UrlGenerationError::ResourceNotFound)
         }
     }
 
@@ -99,7 +101,7 @@ impl ResourceMap {
         name: &str,
         path: &mut String,
         elements: &mut U,
-    ) -> Result<Option<()>, UrlGenerationError>
+    ) -> Result<Option<()>, super::error::UrlGenerationError>
     where
         U: Iterator<Item = I>,
         I: AsRef<str>,
@@ -116,7 +118,7 @@ impl ResourceMap {
         name: &str,
         path: &mut String,
         elements: &mut U,
-    ) -> Result<Option<()>, UrlGenerationError>
+    ) -> Result<Option<()>, super::error::UrlGenerationError>
     where
         U: Iterator<Item = I>,
         I: AsRef<str>,
@@ -128,7 +130,7 @@ impl ResourceMap {
             if pattern.resource_path(path, elements) {
                 Ok(Some(()))
             } else {
-                Err(UrlGenerationError::NotEnoughElements)
+                Err(super::error::UrlGenerationError::NotEnoughElements)
             }
         } else {
             for (_, rmap) in &self.patterns {
@@ -146,7 +148,7 @@ impl ResourceMap {
         &self,
         path: &mut String,
         elements: &mut U,
-    ) -> Result<(), UrlGenerationError>
+    ) -> Result<(), super::error::UrlGenerationError>
     where
         U: Iterator<Item = I>,
         I: AsRef<str>,
@@ -157,7 +159,7 @@ impl ResourceMap {
         if self.root.resource_path(path, elements) {
             Ok(())
         } else {
-            Err(UrlGenerationError::NotEnoughElements)
+            Err(super::error::UrlGenerationError::NotEnoughElements)
         }
     }
 
@@ -166,7 +168,7 @@ impl ResourceMap {
         name: &str,
         path: &mut String,
         elements: &mut U,
-    ) -> Result<Option<()>, UrlGenerationError>
+    ) -> Result<Option<()>, super::error::UrlGenerationError>
     where
         U: Iterator<Item = I>,
         I: AsRef<str>,
@@ -177,7 +179,7 @@ impl ResourceMap {
                 if pattern.resource_path(path, elements) {
                     Ok(Some(()))
                 } else {
-                    Err(UrlGenerationError::NotEnoughElements)
+                    Err(super::error::UrlGenerationError::NotEnoughElements)
                 }
             } else {
                 parent.parent_pattern_for(name, path, elements)

ntex/src/web/scope.rs

@@ -345,7 +345,7 @@ where
             pipeline_factory(filter).and_then_apply_fn(ep, move |result, srv| {
                 match result {
                     Either::Left(req) => Either::Left(srv.call(req)),
-                    Either::Right(res) => Either::Right(Ready::ok(res)),
+                    Either::Right(res) => Either::Right(Ready::Ok(res)),
                 }
             });
 
@@ -640,7 +640,7 @@ impl<Err: ErrorRenderer> Service for ScopeService<Err> {
             Either::Left(default.call(req))
         } else {
             let req = req.into_parts().0;
-            Either::Right(Ready::ok(WebResponse::new(
+            Either::Right(Ready::Ok(WebResponse::new(
                 Response::NotFound().finish(),
                 req,
             )))

ntex/src/web/server.rs

@@ -502,7 +502,7 @@ where
                 c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
             );
             pipeline_factory(|io: UnixStream| {
-                crate::util::Ready::ok((io, Protocol::Http1, None))
+                crate::util::Ready::Ok((io, Protocol::Http1, None))
             })
             .and_then(
                 HttpService::build()
@@ -543,7 +543,7 @@ where
                     c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
                 );
                 pipeline_factory(|io: UnixStream| {
-                    crate::util::Ready::ok((io, Protocol::Http1, None))
+                    crate::util::Ready::Ok((io, Protocol::Http1, None))
                 })
                 .and_then(
                     HttpService::build()

ntex/src/web/test.rs

@@ -51,7 +51,7 @@ pub fn default_service<Err: ErrorRenderer>(
     Error = std::convert::Infallible,
 > {
     (move |req: WebRequest<Err>| {
-        Ready::ok(req.into_response(HttpResponse::build(status_code).finish()))
+        Ready::Ok(req.into_response(HttpResponse::build(status_code).finish()))
     })
     .into_service()
 }

ntex/src/web/types/data.rs

@@ -104,14 +104,14 @@ impl<T: 'static, E: ErrorRenderer> FromRequest<E> for Data<T> {
     #[inline]
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         if let Some(st) = req.app_data::<Data<T>>() {
-            Ready::ok(st.clone())
+            Ready::Ok(st.clone())
         } else {
             log::debug!(
                 "Failed to construct App-level Data extractor. \
                  Request path: {:?}",
                 req.path()
             );
-            Ready::err(DataExtractorError::NotConfigured)
+            Ready::Err(DataExtractorError::NotConfigured)
         }
     }
 }

ntex/src/web/types/path.rs

@@ -158,7 +158,7 @@ where
 
     #[inline]
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        Ready::result(
+        Ready::from(
             de::Deserialize::deserialize(PathDeserializer::new(req.match_info()))
                 .map(|inner| Path { inner })
                 .map_err(move |e| {

ntex/src/web/types/payload.rs

@@ -98,7 +98,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for Payload {
         _: &HttpRequest,
         payload: &mut crate::http::Payload,
     ) -> Self::Future {
-        Ready::ok(Payload(payload.take()))
+        Ready::Ok(Payload(payload.take()))
     }
 }
 
@@ -148,7 +148,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for Bytes {
         };
 
         if let Err(e) = cfg.check_mimetype(req) {
-            return Either::Right(Ready::err(e));
+            return Either::Right(Ready::Err(e));
         }
 
         let limit = cfg.limit;
@@ -206,13 +206,13 @@ impl<Err: ErrorRenderer> FromRequest<Err> for String {
 
         // check content-type
         if let Err(e) = cfg.check_mimetype(req) {
-            return Either::Right(Ready::err(e));
+            return Either::Right(Ready::Err(e));
         }
 
         // check charset
         let encoding = match req.encoding() {
             Ok(enc) => enc,
-            Err(e) => return Either::Right(Ready::err(PayloadError::from(e))),
+            Err(e) => return Either::Right(Ready::Err(PayloadError::from(e))),
         };
         let limit = cfg.limit;
         let fut = HttpMessageBody::new(req, payload).limit(limit);

ntex/src/web/types/query.rs

@@ -134,7 +134,7 @@ where
     #[inline]
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         serde_urlencoded::from_str::<T>(req.query_string())
-            .map(|val| Ready::ok(Query(val)))
+            .map(|val| Ready::Ok(Query(val)))
             .unwrap_or_else(move |e| {
                 let e = QueryPayloadError::Deserialize(e);
 
@@ -143,7 +143,7 @@ where
                      Request path: {:?}",
                     req.path()
                 );
-                Ready::err(e)
+                Ready::Err(e)
             })
     }
 }