Cut further done on dependencies (make script optional) (redis-rs#271)

Author: mitsuhiko

Cargo.toml

@@ -15,28 +15,51 @@ edition = "2018"
 all-features = true
 
 [dependencies]
+# These two are generally really common simple dependencies so it does not seem
+# much of a point to optimize these, but these could in theory be removed for
+# an indirection through std::Formatter.
 dtoa = "0.4"
 itoa = "0.4.3"
+
+# This is a dependency that already exists in url
 percent-encoding = "2.1"
-sha1 = ">= 0.2, < 0.7"
+
+# We need this for redis url parsing
 url = "2.1"
-combine = "3.8.1"
+
+# We need this for script support
+sha1 = { version = ">= 0.2, < 0.7", optional = true }
+
+# Dependency that is shared with tokio.  If we manage to make tokio optional we
+# could also remove this.
 bytes = "0.5"
+
+# These are needed for parsing at the moment 
+combine = "3.8.1"
 futures-util = { version = "0.3.0", features = ["sink"], default-features = false }
 futures-executor = "0.3.0"
+
+# Only needed for AIO
 pin-project-lite = { version = "0.1", optional = true }
-tokio-util = { version = "0.2", features = ["codec"] }
-tokio = "0.2"
+tokio-util = { version = "0.2", features = ["codec"], optional = true }
+
+# Only needed for the r2d2 feature
+r2d2 = { version = "0.8.8", optional = true }
+
+# Only needed for cluster
 crc16 = { version = "0.4.0", optional = true }
 rand = { version = "0.7.0", optional = true }
-r2d2 = { version = "0.8.8", optional = true }
+
+# Unfortunately currently a necessary dependency
+tokio = "0.2"
 
 [features]
-default = ["geospatial", "aio"]
-aio = ["pin-project-lite", "tokio/sync", "tokio/stream", "tokio/tcp", "tokio/uds", "tokio/io-util"]
+default = ["geospatial", "aio", "script"]
+aio = ["pin-project-lite", "tokio/sync", "tokio/stream", "tokio/tcp", "tokio/uds", "tokio/io-util", "tokio-util"]
 tokio-rt-core = ["aio", "tokio/rt-core"]
 geospatial = []
 cluster = ["crc16", "rand"]
+script = ["sha1"]
 
 [dev-dependencies]
 rand = "0.7"

src/aio.rs

@@ -16,8 +16,10 @@ use tokio::{
 };
 use tokio_util::codec::Decoder;
 
+#[cfg(unix)]
+use futures_util::future::Either;
 use futures_util::{
-    future::{Either, Future, FutureExt, TryFutureExt},
+    future::{Future, FutureExt, TryFutureExt},
     ready,
     sink::Sink,
     stream::{Stream, StreamExt},

src/connection.rs

@@ -270,7 +270,7 @@ impl ActualConnection {
                 open: true,
             }),
             #[cfg(not(unix))]
-            ConnectionAddr::Unix(ref path) => {
+            ConnectionAddr::Unix(ref _path) => {
                 fail!((
                     ErrorKind::InvalidClientConfig,
                     "Cannot connect to unix sockets \

src/lib.rs

@@ -49,8 +49,15 @@
 //!
 //! ## Optional Features
 //!
-//! There are currently two features defined that can enable additional
-//! functionality if so desired.
+//! There are a few features defined that can enable additional functionality
+//! if so desired.  Some of them are turned on by default.
+//!
+//! * `aio`: enables async IO support (enabled by default)
+//! * `geospatial`: enables geospatial support (enabled by default)
+//! * `script`: enables script support (enabled by default)
+//! * `r2d2`: enables r2d2 connection pool support (optional)
+//! * `cluster`: enables redis cluster support (optional)
+//! * `tokio-rt-core`: enables support for tokio-rt (optional)
 //!
 //! ## Connection Parameters
 //!
@@ -267,25 +274,30 @@
 //! # }
 //! ```
 //!
-//! # Scripts
-//!
-//! Lua scripts are supported through the `Script` type in a convenient
-//! way (it does not support pipelining currently).  It will automatically
-//! load the script if it does not exist and invoke it.
-//!
-//! Example:
-//!
-//! ```rust,no_run
-//! # fn do_something() -> redis::RedisResult<()> {
-//! # let client = redis::Client::open("redis://127.0.0.1/").unwrap();
-//! # let mut con = client.get_connection().unwrap();
-//! let script = redis::Script::new(r"
-//!     return tonumber(ARGV[1]) + tonumber(ARGV[2]);
-//! ");
-//! let result : isize = script.arg(1).arg(2).invoke(&mut con)?;
-//! assert_eq!(result, 3);
-//! # Ok(()) }
-//! ```
+#![cfg_attr(
+    feature = "script",
+    doc = r##"
+# Scripts
+
+Lua scripts are supported through the `Script` type in a convenient
+way (it does not support pipelining currently).  It will automatically
+load the script if it does not exist and invoke it.
+
+Example:
+
+```rust,no_run
+# fn do_something() -> redis::RedisResult<()> {
+# let client = redis::Client::open("redis://127.0.0.1/").unwrap();
+# let mut con = client.get_connection().unwrap();
+let script = redis::Script::new(r"
+    return tonumber(ARGV[1]) + tonumber(ARGV[2]);
+");
+let result : isize = script.arg(1).arg(2).invoke(&mut con)?;
+assert_eq!(result, 3);
+# Ok(()) }
+```
+"##
+)]
 //!
 //! # Async
 //!
@@ -339,6 +351,8 @@ pub use crate::connection::{
     IntoConnectionInfo, Msg, PubSub,
 };
 pub use crate::parser::{parse_redis_value, parse_redis_value_async, Parser};
+
+#[cfg(feature = "script")]
 pub use crate::script::{Script, ScriptInvocation};
 
 pub use crate::types::{

src/parser.rs

@@ -5,14 +5,12 @@ use std::str;
 
 use crate::types::{make_extension_error, ErrorKind, RedisError, RedisResult, Value};
 
-use bytes::{Buf, BytesMut};
 use combine::{combine_parse_partial, combine_parser_impl, parse_mode, parser};
 use futures_util::{
     future,
     task::{self, Poll},
 };
 use tokio::io::{AsyncBufRead, AsyncRead};
-use tokio_util::codec::{Decoder, Encoder};
 
 use combine;
 use combine::byte::{byte, crlf, take_until_bytes};
@@ -147,51 +145,61 @@ parser! {
     }
 }
 
-#[derive(Default)]
-pub struct ValueCodec {
-    state: AnySendPartialState,
-}
+#[cfg(feature = "aio")]
+mod aio_support {
+    use super::*;
+    use bytes::{Buf, BytesMut};
+    use tokio_util::codec::{Decoder, Encoder};
 
-impl Encoder for ValueCodec {
-    type Item = Vec<u8>;
-    type Error = RedisError;
-    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.extend_from_slice(item.as_ref());
-        Ok(())
+    #[derive(Default)]
+    pub struct ValueCodec {
+        state: AnySendPartialState,
     }
-}
 
-impl Decoder for ValueCodec {
-    type Item = Value;
-    type Error = RedisError;
-    fn decode(&mut self, bytes: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        let (opt, removed_len) = {
-            let buffer = &bytes[..];
-            let stream = combine::easy::Stream(combine::stream::PartialStream(buffer));
-            match combine::stream::decode(value(), stream, &mut self.state) {
-                Ok(x) => x,
-                Err(err) => {
-                    let err = err
-                        .map_position(|pos| pos.translate_position(buffer))
-                        .map_range(|range| format!("{:?}", range))
-                        .to_string();
-                    return Err(RedisError::from((
-                        ErrorKind::ResponseError,
-                        "parse error",
-                        err,
-                    )));
+    impl Encoder for ValueCodec {
+        type Item = Vec<u8>;
+        type Error = RedisError;
+        fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+            dst.extend_from_slice(item.as_ref());
+            Ok(())
+        }
+    }
+
+    impl Decoder for ValueCodec {
+        type Item = Value;
+        type Error = RedisError;
+        fn decode(&mut self, bytes: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+            let (opt, removed_len) = {
+                let buffer = &bytes[..];
+                let stream = combine::easy::Stream(combine::stream::PartialStream(buffer));
+                match combine::stream::decode(value(), stream, &mut self.state) {
+                    Ok(x) => x,
+                    Err(err) => {
+                        let err = err
+                            .map_position(|pos| pos.translate_position(buffer))
+                            .map_range(|range| format!("{:?}", range))
+                            .to_string();
+                        return Err(RedisError::from((
+                            ErrorKind::ResponseError,
+                            "parse error",
+                            err,
+                        )));
+                    }
                 }
-            }
-        };
+            };
 
-        bytes.advance(removed_len);
-        match opt {
-            Some(result) => Ok(Some(result?)),
-            None => Ok(None),
+            bytes.advance(removed_len);
+            match opt {
+                Some(result) => Ok(Some(result?)),
+                None => Ok(None),
+            }
         }
     }
 }
 
+#[cfg(feature = "aio")]
+pub use self::aio_support::*;
+
 // https://github.com/tokio-rs/tokio/pull/1687
 async fn fill_buf<R>(reader: &mut R) -> io::Result<&[u8]>
 where

src/script.rs

@@ -1,3 +1,4 @@
+#![cfg(feature = "script")]
 use sha1::Sha1;
 
 use crate::cmd::cmd;

tests/test_async.rs

@@ -6,7 +6,7 @@ use futures::{future, prelude::*};
 
 use crate::support::*;
 
-use redis::{aio::MultiplexedConnection, RedisError, RedisResult};
+use redis::{aio::MultiplexedConnection, RedisResult};
 
 mod support;
 
@@ -236,7 +236,10 @@ fn test_transaction_multiplexed_connection() {
 }
 
 #[test]
+#[cfg(feature = "script")]
 fn test_script() {
+    use redis::RedisError;
+
     // Note this test runs both scripts twice to test when they have already been loaded
     // into Redis and when they need to be loaded in
     let script1 = redis::Script::new("return redis.call('SET', KEYS[1], ARGV[1])");
@@ -267,6 +270,7 @@ fn test_script() {
 }
 
 #[test]
+#[cfg(feature = "script")]
 fn test_script_returning_complex_type() {
     let ctx = TestContext::new();
     block_on_all(async {

tests/test_basic.rs

@@ -568,6 +568,7 @@ fn scoped_pubsub() {
 }
 
 #[test]
+#[cfg(feature = "script")]
 fn test_script() {
     let ctx = TestContext::new();
     let mut con = ctx.connection();

tests/test_cluster.rs

@@ -43,6 +43,7 @@ fn test_cluster_eval() {
 }
 
 #[test]
+#[cfg(feature = "script")]
 fn test_cluster_script() {
     let cluster = TestClusterContext::new(3, 0);
     let mut con = cluster.connection();