From b4b46ebd587fb9be59360a81623d7080366431f0 Mon Sep 17 00:00:00 2001
From: finga <finga@onders.org>
Date: Sat, 13 Nov 2021 14:16:21 +0100
Subject: [PATCH] Refactor filters

Clean up some comments and refactor the code to improve readability
and to get rid of "ugly" unwraps.
---
 src/webhooks.rs | 38 ++++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/src/webhooks.rs b/src/webhooks.rs
index fee01c7..701c3d4 100644
--- a/src/webhooks.rs
+++ b/src/webhooks.rs
@@ -72,10 +72,6 @@ impl JsonFilter {
         );
 
         let regex = Regex::new(&self.regex).map_err(WebhookeyError::Regex)?;
-        // let value = self.get_string(data)?;
-
-        // if let Some(value) = self.get_string() {data.pointer(&self.pointer) {
-        // let value = get_string();
 
         if let Some(value) = data.pointer(&self.pointer) {
             if regex.is_match(&self.get_string(&value)?) {
@@ -121,33 +117,43 @@ impl FilterType {
     pub fn evaluate(&self, data: &serde_json::Value) -> Result<bool, WebhookeyError> {
         match self {
             FilterType::And(filters) => {
-                let (results, errors): (Vec<_>, Vec<_>) = filters
+                let (mut results, mut errors) = (Vec::new(), Vec::new());
+
+                filters
                     .iter()
                     .map(|filter| filter.evaluate(data))
-                    .partition(Result::is_ok);
+                    .for_each(|item| match item {
+                        Ok(o) => results.push(o),
+                        Err(e) => errors.push(e),
+                    });
 
                 if errors.is_empty() {
-                    Ok(results.iter().all(|r| *r.as_ref().unwrap())) // should never fail
+                    Ok(results.iter().all(|r| *r))
                 } else {
-                    errors.iter().for_each(|e| {
-                        error!("Could not evaluate Filter: {}", e.as_ref().unwrap_err())
-                    });
+                    errors
+                        .iter()
+                        .for_each(|e| error!("Could not evaluate Filter: {}", e));
 
                     Err(WebhookeyError::InvalidFilter)
                 }
             }
             FilterType::Or(filters) => {
-                let (results, errors): (Vec<_>, Vec<_>) = filters
+                let (mut results, mut errors) = (Vec::new(), Vec::new());
+
+                filters
                     .iter()
                     .map(|filter| filter.evaluate(data))
-                    .partition(Result::is_ok);
+                    .for_each(|item| match item {
+                        Ok(o) => results.push(o),
+                        Err(e) => errors.push(e),
+                    });
 
                 if errors.is_empty() {
-                    Ok(results.iter().any(|r| *r.as_ref().unwrap())) // should never fail
+                    Ok(results.iter().any(|r| *r))
                 } else {
-                    errors.iter().for_each(|e| {
-                        error!("Could not evaluate Filter: {}", e.as_ref().unwrap_err())
-                    });
+                    errors
+                        .iter()
+                        .for_each(|e| error!("Could not evaluate Filter: {}", e));
 
                     Err(WebhookeyError::InvalidFilter)
                 }