Reduce dependencies without AIO (redis-rs#266)

Author: jan-auer

Cargo.toml

@@ -24,16 +24,17 @@ combine = "3.8.1"
 bytes = "0.5"
 futures-util = { version = "0.3.0", features = ["sink"], default-features = false }
 futures-executor = "0.3.0"
-pin-project-lite = "0.1"
+pin-project-lite = { version = "0.1", optional = true }
 tokio-util = { version = "0.2", features = ["codec"] }
-tokio = { version = "0.2", features = ["tcp", "uds", "io-util", "sync", "stream"] }
+tokio = "0.2"
 crc16 = { version = "0.4.0", optional = true }
 rand = { version = "0.7.0", optional = true }
 r2d2 = { version = "0.8.8", optional = true }
 
 [features]
-default = ["geospatial"]
-tokio-rt-core = ["tokio/rt-core"]
+default = ["geospatial", "aio"]
+aio = ["pin-project-lite", "tokio/sync", "tokio/stream", "tokio/tcp", "tokio/uds", "tokio/io-util"]
+tokio-rt-core = ["aio", "tokio/rt-core"]
 geospatial = []
 cluster = ["crc16", "rand"]
 
@@ -52,10 +53,18 @@ tokio = { version = "0.2", features = ["rt-core", "macros"] }
 name = "test_async"
 required-features = ["tokio-rt-core"]
 
+[[test]]
+name = "parser"
+required-features = ["aio"]
+
 [[bench]]
 name = "bench_basic"
 harness = false
 
 [[example]]
 name = "async-multiplexed"
 required-features = ["tokio-rt-core"]
+
+[[example]]
+name = "async-await"
+required-features = ["aio"]

Makefile

@@ -3,12 +3,20 @@ build:
 
 test:
 	@echo "===================================================================="
-	@echo "Testing Connection Type TCP"
+	@echo "Testing Connection Type TCP without features"
+	@echo "===================================================================="
+	@REDISRS_SERVER_TYPE=tcp RUST_TEST_THREADS=1 cargo test --no-default-features --tests -- --nocapture
+
+	@echo "===================================================================="
+	@echo "Testing Connection Type TCP with all features"
 	@echo "===================================================================="
 	@REDISRS_SERVER_TYPE=tcp RUST_TEST_THREADS=1 cargo test --all-features -- --nocapture
+
+	@echo "===================================================================="
 	@echo "Testing Connection Type UNIX"
 	@echo "===================================================================="
 	@REDISRS_SERVER_TYPE=unix cargo test --test parser --test test_basic --test test_types --all-features
+
 	@echo "===================================================================="
 	@echo "Testing Connection Type UNIX SOCKETS"
 	@echo "===================================================================="

src/client.rs

@@ -1,4 +1,3 @@
-use std::future::Future;
 use std::time::Duration;
 
 use crate::connection::{connect, Connection, ConnectionInfo, ConnectionLike, IntoConnectionInfo};
@@ -55,6 +54,7 @@ impl Client {
     }
 
     /// Returns an async connection from the client.
+    #[cfg(feature = "aio")]
     pub async fn get_async_connection(&self) -> RedisResult<crate::aio::Connection> {
         crate::aio::connect(&self.connection_info).await
     }
@@ -80,9 +80,13 @@ impl Client {
     ///
     /// A multiplexed connection can be cloned, allowing requests to be be sent concurrently
     /// on the same underlying connection (tcp/unix socket).
+    #[cfg(feature = "aio")]
     pub async fn get_multiplexed_async_connection(
         &self,
-    ) -> RedisResult<(crate::aio::MultiplexedConnection, impl Future<Output = ()>)> {
+    ) -> RedisResult<(
+        crate::aio::MultiplexedConnection,
+        impl std::future::Future<Output = ()>,
+    )> {
         let con = self.get_async_connection().await?;
         Ok(crate::aio::MultiplexedConnection::new(con))
     }

src/cmd.rs

@@ -1,11 +1,15 @@
-use std::{io, pin::Pin};
+use std::io;
 
 use crate::connection::ConnectionLike;
 use crate::types::{
     from_redis_value, ErrorKind, FromRedisValue, RedisResult, RedisWrite, ToRedisArgs, Value,
 };
 
-use tokio::io::{AsyncWrite, AsyncWriteExt};
+#[cfg(feature = "aio")]
+use {
+    std::pin::Pin,
+    tokio::io::{AsyncWrite, AsyncWriteExt},
+};
 
 /// An argument to a redis command
 #[derive(Clone)]
@@ -162,6 +166,7 @@ where
     Ok(())
 }
 
+#[cfg(feature = "aio")]
 async fn write_command_async<'a, I>(
     mut cmd: Pin<&mut (impl ?Sized + AsyncWrite)>,
     args: I,
@@ -217,6 +222,7 @@ fn encode_pipeline(cmds: &[Cmd], atomic: bool) -> Vec<u8> {
     rv
 }
 
+#[cfg(feature = "aio")]
 async fn write_pipeline_async(
     mut out: Pin<&mut (impl ?Sized + AsyncWrite)>,
     cmds: &[Cmd],
@@ -338,6 +344,7 @@ impl Cmd {
         cmd
     }
 
+    #[cfg(feature = "aio")]
     pub(crate) async fn write_command_async(
         &self,
         out: Pin<&mut (impl ?Sized + AsyncWrite)>,
@@ -385,6 +392,7 @@ impl Cmd {
 
     /// Async version of `query`.
     #[inline]
+    #[cfg(feature = "aio")]
     pub async fn query_async<C, T: FromRedisValue>(&self, con: &mut C) -> RedisResult<T>
     where
         C: crate::aio::ConnectionLike,
@@ -596,6 +604,7 @@ impl Pipeline {
         encode_pipeline(&self.commands, self.transaction_mode)
     }
 
+    #[cfg(feature = "aio")]
     pub(crate) async fn write_pipeline_async(
         &self,
         out: Pin<&mut (impl ?Sized + AsyncWrite)>,
@@ -672,6 +681,7 @@ impl Pipeline {
         self.commands.clear();
     }
 
+    #[cfg(feature = "aio")]
     async fn execute_pipelined_async<C>(&self, con: &mut C) -> RedisResult<Value>
     where
         C: crate::aio::ConnectionLike,
@@ -682,6 +692,7 @@ impl Pipeline {
         Ok(self.make_pipeline_results(value))
     }
 
+    #[cfg(feature = "aio")]
     async fn execute_transaction_async<C>(&self, con: &mut C) -> RedisResult<Value>
     where
         C: crate::aio::ConnectionLike,
@@ -702,6 +713,7 @@ impl Pipeline {
 
     /// Async version of `query`.
     #[inline]
+    #[cfg(feature = "aio")]
     pub async fn query_async<C, T: FromRedisValue>(&self, con: &mut C) -> RedisResult<T>
     where
         C: crate::aio::ConnectionLike,

src/commands.rs

@@ -1,6 +1,6 @@
 // can't use rustfmt here because it screws up the file.
 #![cfg_attr(rustfmt, rustfmt_skip)]
-use crate::types::{FromRedisValue, ToRedisArgs, RedisResult, RedisFuture, NumericBehavior};
+use crate::types::{FromRedisValue, ToRedisArgs, RedisResult, NumericBehavior};
 use crate::connection::{ConnectionLike, Msg, Connection};
 use crate::cmd::{cmd, Cmd, Pipeline, Iter};
 
@@ -160,14 +160,15 @@ macro_rules! implement_commands {
         /// assert_eq!(con.get("my_key").await, Ok(42i32));
         /// # Ok(()) }
         /// ```
+        #[cfg(feature = "aio")]
         pub trait AsyncCommands : crate::aio::ConnectionLike + Send + Sized {
             $(
                 $(#[$attr])*
                 #[inline]
                 fn $name<$lifetime, $($tyargs: $ty + Send + Sync + $lifetime,)* RV>(
                     & $lifetime mut self
                     $(, $argname: $argty)*
-                    ) -> RedisFuture<'a, RV>
+                    ) -> crate::types::RedisFuture<'a, RV>
                 where RV: FromRedisValue,
                 {
                     Box::pin(async move { ($body).query_async(self).await })
@@ -1094,6 +1095,7 @@ pub trait PubSubCommands: Sized {
 
 impl<T> Commands for T where T: ConnectionLike {}
 
+#[cfg(feature = "aio")]
 impl<T> AsyncCommands for T where T: crate::aio::ConnectionLike + Send + ?Sized {}
 
 impl PubSubCommands for Connection {

src/lib.rs

@@ -335,7 +335,7 @@
 // public api
 pub use crate::client::Client;
 pub use crate::cmd::{cmd, pack_command, pipe, Arg, Cmd, Iter, Pipeline};
-pub use crate::commands::{AsyncCommands, Commands, ControlFlow, PubSubCommands};
+pub use crate::commands::{Commands, ControlFlow, PubSubCommands};
 pub use crate::connection::{
     parse_redis_url, transaction, Connection, ConnectionAddr, ConnectionInfo, ConnectionLike,
     IntoConnectionInfo, Msg, PubSub,
@@ -368,8 +368,12 @@ pub use crate::types::{
     Value,
 };
 
+#[cfg(feature = "aio")]
+pub use crate::commands::AsyncCommands;
+
 mod macros;
 
+#[cfg(feature = "aio")]
 pub mod aio;
 
 #[cfg(feature = "geospatial")]

src/script.rs

@@ -1,6 +1,5 @@
 use sha1::Sha1;
 
-use crate::aio;
 use crate::cmd::cmd;
 use crate::connection::ConnectionLike;
 use crate::types::{ErrorKind, FromRedisValue, RedisResult, ToRedisArgs};
@@ -150,9 +149,10 @@ impl<'a> ScriptInvocation<'a> {
 
     /// Asynchronously invokes the script and returns the result.
     #[inline]
+    #[cfg(feature = "aio")]
     pub async fn invoke_async<C, T>(&self, con: &mut C) -> RedisResult<T>
     where
-        C: aio::ConnectionLike,
+        C: crate::aio::ConnectionLike,
         T: FromRedisValue,
     {
         let mut eval_cmd = cmd("EVALSHA");

tests/support/mod.rs

@@ -17,14 +17,15 @@ use std::path::PathBuf;
 
 use self::futures::Future;
 
-use redis::{RedisResult, Value};
+use redis::Value;
 
 pub fn current_thread_runtime() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new()
-        .basic_scheduler()
-        .enable_io()
-        .build()
-        .unwrap()
+    let mut builder = tokio::runtime::Builder::new();
+
+    #[cfg(feature = "aio")]
+    builder.enable_io();
+
+    builder.basic_scheduler().build().unwrap()
 }
 
 pub fn block_on_all<F>(f: F) -> F::Output
@@ -185,7 +186,8 @@ impl TestContext {
         self.client.get_connection().unwrap()
     }
 
-    pub async fn async_connection(&self) -> RedisResult<redis::aio::Connection> {
+    #[cfg(feature = "aio")]
+    pub async fn async_connection(&self) -> redis::RedisResult<redis::aio::Connection> {
         self.client.get_async_connection().await
     }
 
@@ -196,7 +198,7 @@ impl TestContext {
     #[cfg(feature = "tokio-rt-core")]
     pub fn multiplexed_async_connection(
         &self,
-    ) -> impl Future<Output = RedisResult<redis::aio::MultiplexedConnection>> {
+    ) -> impl Future<Output = redis::RedisResult<redis::aio::MultiplexedConnection>> {
         let client = self.client.clone();
         async move { client.get_multiplexed_tokio_connection().await }
     }