fix: clippy

Author: joelwurtz

src/action/ffi.rs

@@ -12,15 +12,15 @@ use std::ptr::null;
 /// Returns null if an error happens, otherwise it returns a pointer to an action
 pub unsafe extern "C" fn redirectionio_action_json_deserialize(str: *mut c_char) -> *const Action {
     let action_str = match c_char_to_str(str) {
-        None => return null() as *const Action,
+        None => return null(),
         Some(str) => str,
     };
 
     let action = match json_decode(action_str) {
         Err(error) => {
             error!("Unable to deserialize \"{}\" to action: {}", action_str, error,);
 
-            return null() as *const Action;
+            return null();
         }
         Ok(action) => action,
     };
@@ -96,7 +96,7 @@ pub unsafe extern "C" fn redirectionio_action_body_filter_create(
     response_header_map: *const HeaderMap,
 ) -> *const FilterBodyAction {
     if _action.is_null() {
-        return null() as *const FilterBodyAction;
+        return null();
     }
 
     let action = &mut *_action;

src/api/ffi.rs

@@ -15,14 +15,14 @@ pub unsafe extern "C" fn redirectionio_api_get_rule_api_version() -> *const c_ch
 #[no_mangle]
 pub unsafe extern "C" fn redirectionio_api_create_rules_message_from_json(content: *mut c_char) -> *const RulesMessage {
     let message_string = match c_char_to_str(content) {
-        None => return null() as *const RulesMessage,
+        None => return null(),
         Some(str) => str,
     };
 
     match json_decode(message_string) {
         Err(error) => {
             error!("{}", error);
-            null() as *const RulesMessage
+            null()
         }
         Ok(message) => Box::into_raw(Box::new(message)),
     }

src/ffi.rs

@@ -82,7 +82,7 @@ pub unsafe extern "C" fn redirectionio_router_drop(_router: *mut Router<Rule>) {
 #[no_mangle]
 pub unsafe extern "C" fn redirectionio_router_match_action(_router: *const Router<Rule>, _request: *const Request) -> *const Action {
     if _router.is_null() || _request.is_null() {
-        return null() as *const Action;
+        return null();
     }
 
     let router = &*_router;

src/http/ffi.rs

@@ -15,7 +15,7 @@ pub struct HeaderMap {
 
 /// # Safety
 pub unsafe fn http_headers_to_header_map(headers: Vec<Header>) -> *const HeaderMap {
-    let mut current: *const HeaderMap = null() as *const HeaderMap;
+    let mut current: *const HeaderMap = null();
 
     for header in &headers {
         current = Box::into_raw(Box::new(HeaderMap {
@@ -59,15 +59,15 @@ pub unsafe fn header_map_to_http_headers(header_map: *const HeaderMap) -> Vec<He
 /// # Safety
 pub unsafe extern "C" fn redirectionio_request_json_deserialize(str: *mut c_char) -> *const Request {
     let request_str = match c_char_to_str(str) {
-        None => return null() as *const Request,
+        None => return null(),
         Some(str) => str,
     };
 
     let request = match json_decode(request_str) {
         Err(err) => {
             error!("cannot deserialize request {} for string {}", err, request_str);
 
-            return null() as *const Request;
+            return null();
         }
         Ok(request) => request,
     };
@@ -201,7 +201,7 @@ pub unsafe extern "C" fn redirectionio_request_from_str(_url: *const c_char) ->
         Err(err) => {
             error!("cannot create request for url {}: {}", url, err);
 
-            null() as *const Request
+            null()
         }
         Ok(request) => Box::into_raw(Box::new(request)),
     }

src/regex_radix_tree/item.rs

@@ -76,6 +76,14 @@ impl<V> Item<V> {
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Item::Empty(_) => true,
+            Item::Node(node) => node.is_empty(),
+            Item::Leaf(leaf) => leaf.is_empty(),
+        }
+    }
+
     pub fn regex(&self) -> &str {
         match self {
             Item::Empty(_) => "",
@@ -96,7 +104,7 @@ impl<V> Item<V> {
     /// Implementation must retain at which level this node is build and not do any caching
     /// if we are not on the current level
     pub fn cache(&mut self, left: u64, cache_level: u64, current_level: u64) -> u64 {
-        if left <= 0 {
+        if left == 0 {
             return left;
         }
 

src/regex_radix_tree/leaf.rs

@@ -104,6 +104,10 @@ impl<V> Leaf<V> {
         self.values.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
     pub fn regex(&self) -> &str {
         self.regex.original.as_str()
     }

src/regex_radix_tree/node.rs

@@ -124,7 +124,7 @@ impl<V> Node<V> {
                     removed = value;
                 }
 
-                if child.len() > 0 {
+                if !child.is_empty() {
                     children.push(child);
                 }
             }
@@ -150,6 +150,16 @@ impl<V> Node<V> {
         count
     }
 
+    pub fn is_empty(&self) -> bool {
+        for child in &self.children {
+            if !child.is_empty() {
+                return false;
+            }
+        }
+
+        true
+    }
+
     /// Cache current regex according to a limit and a level
     ///
     /// This method must return new limit of element cached (passed limit minus number of element cached)
@@ -167,7 +177,7 @@ impl<V> Node<V> {
             self.regex.compile();
 
             if self.regex.compiled.is_some() {
-                left = left - 1;
+                left -= 1;
             }
         }
 

src/regex_radix_tree/prefix.rs

@@ -9,9 +9,8 @@ macro_rules! next_char_or_return {
 
 pub fn common_prefix(left: &str, right: &str) -> String {
     let size = common_prefix_char_size(left, right);
-    let prefix = get_prefix_with_char_size(left, size);
 
-    prefix
+    get_prefix_with_char_size(left, size)
 }
 
 pub fn common_prefix_char_size(left: &str, right: &str) -> u32 {

src/regex_radix_tree/regex.rs

@@ -48,7 +48,7 @@ impl LazyRegex {
     }
 
     pub fn create_regex(&self) -> Option<Regex> {
-        match RegexBuilder::new(&self.regex.as_str()).case_insensitive(self.ignore_case).build() {
+        match RegexBuilder::new(self.regex.as_str()).case_insensitive(self.ignore_case).build() {
             Ok(regex) => Some(regex),
             Err(e) => {
                 tracing::error!("cannot create regex: {:?}", e);

src/regex_radix_tree/trace.rs

@@ -20,7 +20,7 @@ impl<V> Leaf<V> {
             matched,
             count: self.values.len() as u64,
             children: Vec::new(),
-            values: self.values.values().into_iter().collect(),
+            values: self.values.values().collect(),
         }
     }
 }