Merge pull request #264 from H1rono/tidy-up-deps

H1rono · web-flow · commit f28e2087af97 · 2024-12-13T08:57:07.000+09:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -39,8 +39,8 @@ optional = true
 
 [dependencies.chrono]
 version = "0.4"
-optional = true
 features = ["serde"]
+optional = true
 
 [dependencies.bytes]
 version = "1"
@@ -62,19 +62,14 @@ version = "0.1"
 features = []
 optional = true
 
-[dependencies.tower]
-version = "0.5"
-default-features = false
-features = ["util"]
-optional = true
-
-[dependencies.tower-http]
-version = "0.6"
-default-features = false
+[dependencies.futures-core]
+version = "0.3"
+features = []
 optional = true
 
-[dependencies.futures]
+[dependencies.futures-util]
 version = "0.3"
+default-features = false
 features = []
 optional = true
 
@@ -83,16 +78,30 @@ version = "0.2"
 features = []
 optional = true
 
+[dependencies.tower-service]
+version = "0.3"
+features = []
+optional = true
+
 [dev-dependencies]
 http = "1"
 futures = { version = "0.3", features = ["executor"] }
+tower = { version = "0.5", features = ["util"] }
 
 [features]
 uuid = ["dep:uuid"]
 time = ["dep:time"]
 chrono = ["dep:chrono"]
-http = ["dep:bytes", "dep:http", "dep:http-body", "dep:http-body-util", "dep:pin-project-lite", "dep:futures"]
-tower = ["http", "dep:tower", "dep:tower-http"]
+http = [
+    "dep:bytes",
+    "dep:http",
+    "dep:http-body",
+    "dep:http-body-util",
+    "dep:pin-project-lite",
+    "dep:futures-core",
+    "dep:futures-util",
+]
+tower = ["http", "dep:tower-service"]
 
 [lints.clippy]
 pedantic.level = "deny"
diff --git a/src/handler.rs b/src/handler.rs
@@ -9,10 +9,9 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 
-use futures::future::Ready as ReadyFuture;
 use http::{Request, Response};
 use paste::paste;
-use tower::Service;
+use tower_service::Service;
 
 use super::Handler;
 use crate::macros::all_events;
@@ -43,15 +42,15 @@ impl Sink {
 impl<T> Service<T> for Sink {
     type Response = ();
     type Error = Error;
-    type Future = ReadyFuture<Result<(), Error>>;
+    type Future = futures_util::future::Ready<Result<(), Error>>;
 
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
     #[inline]
     fn call(&mut self, _request: T) -> Self::Future {
-        futures::future::ready(Ok(()))
+        futures_util::future::ready(Ok(()))
     }
 }
 
diff --git a/src/handler/future.rs b/src/handler/future.rs
@@ -3,11 +3,11 @@ use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures::ready;
+use futures_core::ready;
 use http::{Response, StatusCode};
 use http_body::Body;
 use pin_project_lite::pin_project;
-use tower::Service;
+use tower_service::Service;
 
 use crate::error::{Error, Result};
 use crate::events::Event;
diff --git a/src/macros.rs b/src/macros.rs
@@ -379,7 +379,7 @@ macro_rules! event_service_types {
     () => {
         type Response = ();
         type Error = $crate::Error;
-        type Future = ::futures::future::Either<
+        type Future = ::futures_util::future::Either<
             $crate::handler::WrapErrorFuture<Service::Future, Service::Error>,
             Fallback::Future,
         >;
@@ -393,12 +393,15 @@ macro_rules! event_service_poll_ready {
             &mut self,
             cx: &mut ::std::task::Context<'_>,
         ) -> ::std::task::Poll<::std::result::Result<(), Self::Error>> {
-            if let ::std::result::Result::Err(e) = ::futures::ready!(self.inner.poll_ready(cx)) {
+            if let ::std::result::Result::Err(e) = ::futures_core::ready!(self.inner.poll_ready(cx))
+            {
                 return ::std::task::Poll::Ready(::std::result::Result::Err(
                     $crate::Error::handler(e),
                 ));
             }
-            if let ::std::result::Result::Err(e) = ::futures::ready!(self.fallback.poll_ready(cx)) {
+            if let ::std::result::Result::Err(e) =
+                ::futures_core::ready!(self.fallback.poll_ready(cx))
+            {
                 return ::std::task::Poll::Ready(::std::result::Result::Err(e));
             }
             ::std::task::Poll::Ready(::std::result::Result::Ok(()))
@@ -415,10 +418,10 @@ macro_rules! event_service_call {
         $( #[$m] )*
         fn call(&mut self, req: $crate::Event) -> Self::Future {
             match req {
-                $crate::Event::$v($i) => ::futures::future::Either::Left(
+                $crate::Event::$v($i) => ::futures_util::future::Either::Left(
                     $crate::handler::WrapErrorFuture::new(self.inner.call($i)),
                 ),
-                event => ::futures::future::Either::Right(self.fallback.call(event)),
+                event => ::futures_util::future::Either::Right(self.fallback.call(event)),
             }
         }
     };
@@ -431,10 +434,10 @@ macro_rules! event_service_call {
         fn call(&mut self, req: (State, $crate::handler::Event)) -> Self::Future {
             let ($s, event) = req;
             match event {
-                $crate::Event::$v($i) => ::futures::future::Either::Left(
+                $crate::Event::$v($i) => ::futures_util::future::Either::Left(
                     $crate::handler::WrapErrorFuture::new(self.inner.call($e)),
                 ),
-                event => ::futures::future::Either::Right(self.fallback.call(($s, event))),
+                event => ::futures_util::future::Either::Right(self.fallback.call(($s, event))),
             }
         }
     };
@@ -455,14 +458,14 @@ macro_rules! event_service {
             fallback: Fallback,
         }
 
-        impl<Service, Fallback> ::tower::Service<$crate::Event>
+        impl<Service, Fallback> ::tower_service::Service<$crate::Event>
         for [< On $e:camel >] <Service, Fallback, $crate::payloads::[< $e:camel Payload >] >
         where
-            Service: ::tower::Service<$crate::payloads::[< $e:camel Payload >], Response = ()>,
+            Service: ::tower_service::Service<$crate::payloads::[< $e:camel Payload >], Response = ()>,
             Service::Error: ::std::convert::Into<::std::boxed::Box<
                 dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
             >>,
-            Fallback: ::tower::Service<$crate::Event, Response = (), Error = $crate::Error>,
+            Fallback: ::tower_service::Service<$crate::Event, Response = (), Error = $crate::Error>,
         {
             $crate::macros::event_service_types! {}
             $crate::macros::event_service_poll_ready! {}
@@ -472,14 +475,14 @@ macro_rules! event_service {
             }
         }
 
-        impl<State, Service, Fallback> ::tower::Service<(State, $crate::handler::Event)>
+        impl<State, Service, Fallback> ::tower_service::Service<(State, $crate::handler::Event)>
         for [< On $e:camel >] <Service, Fallback, $crate::payloads::[< $e:camel Payload >] >
         where
-            Service: ::tower::Service<$crate::payloads::[< $e:camel Payload >], Response = ()>,
+            Service: ::tower_service::Service<$crate::payloads::[< $e:camel Payload >], Response = ()>,
             Service::Error: ::std::convert::Into<::std::boxed::Box<
                 dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
             >>,
-            Fallback: ::tower::Service<
+            Fallback: ::tower_service::Service<
                 (State, $crate::handler::Event),
                 Response = (),
                 Error = $crate::Error,
@@ -494,17 +497,17 @@ macro_rules! event_service {
             }
         }
 
-        impl<State, Service, Fallback> ::tower::Service<(State, $crate::handler::Event)>
+        impl<State, Service, Fallback> ::tower_service::Service<(State, $crate::handler::Event)>
         for [< On $e:camel >] <Service, Fallback, (State, $crate::payloads::[< $e:camel Payload >] )>
         where
-            Service: ::tower::Service<
+            Service: ::tower_service::Service<
                 (State, $crate::payloads::[< $e:camel Payload >]),
                 Response = (),
             >,
             Service::Error: ::std::convert::Into<::std::boxed::Box<
                 dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
             >>,
-            Fallback: ::tower::Service<
+            Fallback: ::tower_service::Service<
                 (State, $crate::handler::Event),
                 Response = (),
                 Error = $crate::Error
@@ -533,7 +536,7 @@ macro_rules! handler_on_events {
                 $v fn [< on_ $e:snake:lower >] <Service2, Req> (self, service: Service2)
                 -> $crate::Handler<$crate::handler::[< On $e:camel >] <Service2, Service1, Req>>
                 where
-                    Service2: ::tower::Service<Req>,
+                    Service2: ::tower_service::Service<Req>,
                 {
                     let Self {
                         service: fallback,
diff --git a/src/parser/http.rs b/src/parser/http.rs
@@ -5,8 +5,8 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use bytes::Bytes;
-use futures::future::Ready;
-use futures::ready;
+use futures_core::ready;
+use futures_util::future::Ready;
 use http_body::Body;
 use http_body_util::{combinators::Collect, Collected};
 use pin_project_lite::pin_project;
@@ -72,7 +72,7 @@ where
                 }
             }
             Err(e) => ParseRequestInner::ParseEventKindFailed {
-                inner: futures::future::ready(Err(e)),
+                inner: futures_util::future::ready(Err(e)),
             },
         };
         Poll::Ready(next)
@@ -190,7 +190,7 @@ where
     fn new(kind: Result<EventKind>, body: B) -> Self {
         use http_body_util::BodyExt;
 
-        let kind = futures::future::ready(kind);
+        let kind = futures_util::future::ready(kind);
         let body = CollectBody {
             collect: body.collect(),
         };
