redis 0.21

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nextcloud-config-parser"
 description = "Rust parser for nextcloud config files"
-version = "0.2.3"
+version = "0.3.0"
 authors = ["Robin Appelman <robin@icewind.nl>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -9,7 +9,7 @@ repository = "https://github.com/icewind1991/nextcloud-config-parser"
 documentation = "https://docs.rs/nextcloud-config-parser"
 
 [dependencies]
-redis = { version = "0.20", optional = true }
+redis = { version = "0.21", optional = true }
 thiserror = "1"
 php-literal-parser =  { version = "0.2", default-features = false }
 sqlx = { version = "0.5", features = ["any", "mysql", "sqlite", "postgres"], optional = true }

src/lib.rs

@@ -30,35 +30,37 @@ pub enum RedisConfig {
 impl RedisConfig {
     pub fn addr(&self) -> impl Iterator<Item = &ConnectionAddr> {
         let boxed: Box<dyn Iterator<Item = &ConnectionAddr>> = match self {
-            RedisConfig::Single(conn) => Box::new(once(conn.addr.as_ref())),
+            RedisConfig::Single(conn) => Box::new(once(&conn.addr)),
-            RedisConfig::Cluster(conns) => Box::new(conns.iter().map(|conn| conn.addr.as_ref())),
+            RedisConfig::Cluster(conns) => Box::new(conns.iter().map(|conn| &conn.addr)),
         };
         boxed
     }
 
     pub fn db(&self) -> i64 {
         match self {
-            RedisConfig::Single(conn) => conn.db,
+            RedisConfig::Single(conn) => conn.redis.db,
-            RedisConfig::Cluster(conns) => conns.first().map(|conn| conn.db).unwrap_or_default(),
+            RedisConfig::Cluster(conns) => {
+                conns.first().map(|conn| conn.redis.db).unwrap_or_default()
+            }
         }
     }
 
     pub fn username(&self) -> Option<&str> {
         match self {
-            RedisConfig::Single(conn) => conn.username.as_deref(),
+            RedisConfig::Single(conn) => conn.redis.username.as_deref(),
             RedisConfig::Cluster(conns) => conns
                 .first()
-                .map(|conn| conn.username.as_deref())
+                .map(|conn| conn.redis.username.as_deref())
                 .unwrap_or_default(),
         }
     }
 
     pub fn passwd(&self) -> Option<&str> {
         match self {
-            RedisConfig::Single(conn) => conn.passwd.as_deref(),
+            RedisConfig::Single(conn) => conn.redis.password.as_deref(),
             RedisConfig::Cluster(conns) => conns
                 .first()
-                .map(|conn| conn.passwd.as_deref())
+                .map(|conn| conn.redis.password.as_deref())
                 .unwrap_or_default(),
         }
     }

src/nc.rs

@@ -298,26 +298,30 @@ fn parse_redis_options(parsed: &Value) -> RedisConfig {
     };
 
     let db = redis_options["dbindex"].clone().into_int().unwrap_or(0);
-    let passwd = redis_options["password"]
+    let password = redis_options["password"]
         .as_str()
         .filter(|pass| !pass.is_empty())
         .map(String::from);
 
     match address {
         RedisAddress::Single(addr) => RedisConfig::Single(ConnectionInfo {
-            addr: Box::new(addr),
+            addr,
-            db,
+            redis: RedisConnectionInfo {
-            username: None,
+                db,
-            passwd,
+                username: None,
+                password,
+            },
         }),
         RedisAddress::Cluster(addresses) => RedisConfig::Cluster(
             addresses
                 .into_iter()
                 .map(|addr| ConnectionInfo {
-                    addr: Box::new(addr),
+                    addr,
-                    db,
+                    redis: RedisConnectionInfo {
-                    username: None,
+                        db,
-                    passwd: passwd.clone(),
+                        username: None,
+                        password: password.clone(),
+                    },
                 })
                 .collect(),
         ),
@@ -346,6 +350,7 @@ fn assert_debug_equal<T: Debug>(a: T, b: T) {
     assert_eq!(format!("{:?}", a), format!("{:?}", b),);
 }
 
+use redis::RedisConnectionInfo;
 #[cfg(test)]
 #[allow(unused_imports)]
 use sqlx::{any::AnyConnectOptions, postgres::PgConnectOptions};