From b7ad590d39403e767872ffd1b2c8c05cd5cc1b27 Mon Sep 17 00:00:00 2001
From: finga <finga@onders.org>
Date: Fri, 19 Nov 2021 11:04:11 +0100
Subject: [PATCH] Create interrelate macro to evaluate filters

This reduces code duplication.
---
 src/webhooks.rs | 68 +++++++++++++++++++------------------------------
 1 file changed, 26 insertions(+), 42 deletions(-)

diff --git a/src/webhooks.rs b/src/webhooks.rs
index 625af56..4029d38 100644
--- a/src/webhooks.rs
+++ b/src/webhooks.rs
@@ -120,6 +120,30 @@ impl JsonFilter {
     }
 }
 
+macro_rules! interrelate {
+    ($request:expr, $data:expr, $filters:expr, $relation:ident) => {{
+        let (mut results, mut errors) = (Vec::new(), Vec::new());
+
+        $filters
+            .iter()
+            .map(|filter| filter.evaluate($request, $data))
+            .for_each(|item| match item {
+                Ok(o) => results.push(o),
+                Err(e) => errors.push(e),
+            });
+
+        if errors.is_empty() {
+            Ok(results.iter().$relation(|r| *r))
+        } else {
+            errors
+                .iter()
+                .for_each(|e| error!("Could not evaluate Filter: {}", e));
+
+            Err(WebhookeyError::InvalidFilter)
+        }
+    }};
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "lowercase")]
 pub enum FilterType {
@@ -140,48 +164,8 @@ impl FilterType {
     ) -> Result<bool, WebhookeyError> {
         match self {
             FilterType::Not(filter) => Ok(!filter.evaluate(request, data)?),
-            FilterType::And(filters) => {
-                let (mut results, mut errors) = (Vec::new(), Vec::new());
-
-                filters
-                    .iter()
-                    .map(|filter| filter.evaluate(request, data))
-                    .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))
-                } else {
-                    errors
-                        .iter()
-                        .for_each(|e| error!("Could not evaluate Filter: {}", e));
-
-                    Err(WebhookeyError::InvalidFilter)
-                }
-            }
-            FilterType::Or(filters) => {
-                let (mut results, mut errors) = (Vec::new(), Vec::new());
-
-                filters
-                    .iter()
-                    .map(|filter| filter.evaluate(request, data))
-                    .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))
-                } else {
-                    errors
-                        .iter()
-                        .for_each(|e| error!("Could not evaluate Filter: {}", e));
-
-                    Err(WebhookeyError::InvalidFilter)
-                }
-            }
+            FilterType::And(filters) => interrelate!(request, data, filters, all),
+            FilterType::Or(filters) => interrelate!(request, data, filters, any),
             FilterType::HeaderFilter(filter) => filter.evaluate(request.headers()),
             FilterType::JsonFilter(filter) => filter.evaluate(data),
         }