fix clippy warnings/errors

Signed-off-by: Eren Atas <[email protected]>

Author: erenatas

crates/flagd/src/cache/service.rs

@@ -159,6 +159,9 @@ impl CacheKey {
     }
 }
 
+/// Type alias for the thread-safe cache implementation
+type SharedCache<V> = Arc<RwLock<Box<dyn Cache<CacheKey, CacheEntry<V>>>>>;
+
 /// Service managing cache operations and lifecycle
 #[derive(Debug)]
 pub struct CacheService<V>
@@ -170,7 +173,7 @@ where
     /// Time-to-live configuration for cache entries
     ttl: Option<Duration>,
     /// The underlying cache implementation
-    cache: Arc<RwLock<Box<dyn Cache<CacheKey, CacheEntry<V>>>>>,
+    cache: SharedCache<V>,
 }
 
 impl<V> CacheService<V>
@@ -218,11 +221,11 @@ where
         let mut cache = self.cache.write().await;
 
         if let Some(entry) = cache.get(&cache_key) {
-            if let Some(ttl) = self.ttl {
-                if entry.created_at.elapsed() > ttl {
-                    cache.remove(&cache_key);
-                    return None;
-                }
+            if let Some(ttl) = self.ttl
+                && entry.created_at.elapsed() > ttl
+            {
+                cache.remove(&cache_key);
+                return None;
             }
             return Some(entry.value.clone());
         }

crates/flagd/src/lib.rs

@@ -470,11 +470,10 @@ impl FlagdProvider {
         context: &EvaluationContext,
         value_converter: impl Fn(Value) -> Option<T>,
     ) -> Option<T> {
-        if let Some(cache) = &self.cache {
-            if let Some(cached_value) = cache.get(flag_key, context).await {
+        if let Some(cache) = &self.cache
+            && let Some(cached_value) = cache.get(flag_key, context).await {
                 return value_converter(cached_value);
             }
-        }
         None
     }
 }

crates/flagd/src/resolver/in_process/model/flag_parser.rs

@@ -21,7 +21,7 @@ impl FlagParser {
         let flag_set_metadata = obj
             .get("metadata")
             .and_then(|v| v.as_object())
-            .map(|m| Self::convert_map_to_hashmap(m))
+            .map(Self::convert_map_to_hashmap)
             .unwrap_or_default();
 
         let mut flag_map = HashMap::new();

crates/flagd/src/resolver/in_process/resolver/file.rs

@@ -50,15 +50,14 @@ impl FileResolver {
         value_converter: impl Fn(&serde_json::Value) -> Option<T>,
         type_name: &str,
     ) -> Result<ResolutionDetails<T>, EvaluationError> {
-        if let Some(cache) = &self.cache {
-            if let Some(cached_value) = cache.get(flag_key, context).await {
+        if let Some(cache) = &self.cache
+            && let Some(cached_value) = cache.get(flag_key, context).await {
                 debug!("Cache hit for key: {}", flag_key);
                 let json_value = cached_value.to_serde_json();
                 if let Some(value) = value_converter(&json_value) {
                     return Ok(ResolutionDetails::new(value));
                 }
             }
-        }
 
         let query_result = self.store.get_flag(flag_key).await;
 

crates/flagd/src/resolver/in_process/resolver/grpc.rs

@@ -85,11 +85,10 @@ impl InProcessResolver {
         context: &EvaluationContext,
         value_converter: impl Fn(&OpenFeatureValue) -> Option<T>,
     ) -> Option<T> {
-        if let Some(cache) = &self.cache {
-            if let Some(cached_value) = cache.get(flag_key, context).await {
+        if let Some(cache) = &self.cache
+            && let Some(cached_value) = cache.get(flag_key, context).await {
                 return value_converter(&cached_value);
             }
-        }
         None
     }
 
@@ -117,7 +116,7 @@ impl InProcessResolver {
                 OpenFeatureValue::Array(arr) => {
                     // Convert OpenFeature array to JsonValue array
                     let json_array =
-                        JsonValue::Array(arr.iter().map(|v| convert_to_json_value(v)).collect());
+                        JsonValue::Array(arr.iter().map(convert_to_json_value).collect());
                     value_converter(&json_array)
                 }
             })
@@ -309,7 +308,7 @@ fn convert_to_json_value(value: &OpenFeatureValue) -> JsonValue {
         OpenFeatureValue::Float(f) => JsonValue::Number(serde_json::Number::from_f64(*f).unwrap()),
         OpenFeatureValue::Struct(s) => convert_struct_to_json(s),
         OpenFeatureValue::Array(arr) => {
-            JsonValue::Array(arr.iter().map(|v| convert_to_json_value(v)).collect())
+            JsonValue::Array(arr.iter().map(convert_to_json_value).collect())
         }
     }
 }

crates/flagd/src/resolver/in_process/targeting/mod.rs

@@ -14,6 +14,12 @@ pub struct Operator {
     logic: Arc<DataLogic>,
 }
 
+impl Default for Operator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Operator {
     pub fn new() -> Self {
         // Create a new DataLogic instance

crates/flagd/src/resolver/rpc.rs

@@ -158,8 +158,8 @@ impl RpcResolver {
         let mut endpoint = upstream_config.endpoint().clone();
 
         // Extend support for envoy names resolution
-        if let Some(uri) = &options.target_uri {
-            if uri.starts_with("envoy://") {
+        if let Some(uri) = &options.target_uri
+            && uri.starts_with("envoy://") {
                 // Expected format: envoy://<host:port>/<desired_authority>
                 let without_prefix = uri.trim_start_matches("envoy://");
                 let segments: Vec<&str> = without_prefix.split('/').collect();
@@ -171,7 +171,6 @@ impl RpcResolver {
                     endpoint = endpoint.origin(authority_uri);
                 }
             }
-        }
 
         let channel = endpoint
             .timeout(Duration::from_millis(options.deadline_ms as u64))