Update Names etc

Author: EmilyMatt

src/client/builder.rs

@@ -119,7 +119,6 @@ mod tests {
     }
 
     #[test]
-
     fn test_sync_builder_redis_fallback() {
         let client = FalkorClientBuilder::new().build();
         assert!(client.is_ok());

src/connection/blocking.rs

@@ -73,7 +73,7 @@ impl FalkorSyncConnection {
                             .map(|[key, val]| (key.to_string(), val.to_string()))
                             .collect()
                     })
-                    .map_err(|_| FalkorDBError::ParsingFString)
+                    .map_err(|_| FalkorDBError::ParsingString)
             })
     }
 }

src/connection_info/mod.rs

@@ -82,7 +82,6 @@ mod tests {
     use std::{mem, str::FromStr};
 
     #[test]
-
     fn test_redis_fallback_provider() {
         let FalkorConnectionInfo::Redis(redis) =
             FalkorConnectionInfo::fallback_provider("redis://127.0.0.1:6379".to_string()).unwrap();
@@ -91,7 +90,6 @@ mod tests {
     }
 
     #[test]
-
     fn test_try_from_redis() {
         let res = FalkorConnectionInfo::try_from("redis://0.0.0.0:1234");
         assert!(res.is_ok());

src/error/mod.rs

@@ -79,21 +79,21 @@ pub enum FalkorDBError {
     /// Element was not of type Array.
     #[error("Element was not of type Array")]
     ParsingArray,
-    /// Element was not of type FString.
-    #[error("Element was not of type FString")]
-    ParsingFString,
+    /// Element was not of type String.
+    #[error("Element was not of type String")]
+    ParsingString,
     /// Element was not of type FEdge.
     #[error("Element was not of type FEdge")]
     ParsingFEdge,
     /// Element was not of type FNode.
     #[error("Element was not of type FNode")]
     ParsingFNode,
-    /// Element was not of type FPath.
-    #[error("Element was not of type FPath")]
-    ParsingFPath,
-    /// Element was not of type FMap.
-    #[error("Element was not of type FMap")]
-    ParsingFMap,
+    /// Element was not of type Path.
+    #[error("Element was not of type Path")]
+    ParsingPath,
+    /// Element was not of type Map.
+    #[error("Element was not of type Map")]
+    ParsingMap,
     /// Element was not of type FPoint.
     #[error("Element was not of type FPoint")]
     ParsingFPoint,

src/parser/mod.rs

@@ -9,10 +9,10 @@ use std::collections::HashMap;
 pub(crate) fn redis_value_as_string(value: redis::Value) -> FalkorResult<String> {
     match value {
         redis::Value::Data(data) => {
-            String::from_utf8(data).map_err(|_| FalkorDBError::ParsingFString)
+            String::from_utf8(data).map_err(|_| FalkorDBError::ParsingString)
         }
         redis::Value::Status(status) => Ok(status),
-        _ => Err(FalkorDBError::ParsingFString),
+        _ => Err(FalkorDBError::ParsingString),
     }
 }
 
@@ -176,7 +176,7 @@ fn parse_regular_falkor_map(
 ) -> FalkorResult<HashMap<String, FalkorValue>> {
     value
         .into_map_iter()
-        .map_err(|_| FalkorDBError::ParsingFMap)?
+        .map_err(|_| FalkorDBError::ParsingMap)?
         .try_fold(HashMap::new(), |mut out_map, (key, val)| {
             out_map.insert(
                 redis_value_as_string(key)?,

src/value/config.rs

@@ -102,7 +102,7 @@ impl TryFrom<redis::Value> for ConfigValue {
         Ok(match value {
             redis::Value::Int(int_val) => ConfigValue::Int64(int_val),
             redis::Value::Data(str_data) => ConfigValue::String(
-                String::from_utf8(str_data).map_err(|_| FalkorDBError::ParsingFString)?,
+                String::from_utf8(str_data).map_err(|_| FalkorDBError::ParsingString)?,
             ),
             _ => return Err(FalkorDBError::InvalidDataReceived),
         })

src/value/mod.rs

@@ -84,7 +84,7 @@ impl FalkorValue {
         }
     }
 
-    /// Returns a reference to the internal [`String`] if this is an FString variant.
+    /// Returns a reference to the internal [`String`] if this is an String variant.
     ///
     /// # Returns
     /// A reference to the internal [`String`]
@@ -117,7 +117,7 @@ impl FalkorValue {
         }
     }
 
-    /// Returns a reference to the internal [`Path`] if this is an FPath variant.
+    /// Returns a reference to the internal [`Path`] if this is an Path variant.
     ///
     /// # Returns
     /// A reference to the internal [`Path`]
@@ -128,7 +128,7 @@ impl FalkorValue {
         }
     }
 
-    /// Returns a reference to the internal [`HashMap`] if this is an FMap variant.
+    /// Returns a reference to the internal [`HashMap`] if this is an Map variant.
     ///
     /// # Returns
     /// A reference to the internal [`HashMap`]
@@ -199,14 +199,14 @@ impl FalkorValue {
         }
     }
 
-    /// Consumes itself and returns the inner [`String`] if this is an FString variant
+    /// Consumes itself and returns the inner [`String`] if this is an String variant
     ///
     /// # Returns
     /// The inner [`String`]
     pub fn into_string(self) -> FalkorResult<String> {
         match self {
             FalkorValue::String(string) => Ok(string),
-            _ => Err(FalkorDBError::ParsingFString),
+            _ => Err(FalkorDBError::ParsingString),
         }
     }
     /// Consumes itself and returns the inner [`HashMap`] if this is a Map variant
@@ -216,7 +216,7 @@ impl FalkorValue {
     pub fn into_map(self) -> FalkorResult<HashMap<String, FalkorValue>> {
         match self {
             FalkorValue::Map(map) => Ok(map),
-            _ => Err(FalkorDBError::ParsingFMap),
+            _ => Err(FalkorDBError::ParsingMap),
         }
     }
 }