feat: regex constraints (#338)

Author: sighphyre

.github/workflows/sarif-and-test.yaml

@@ -51,7 +51,7 @@ jobs:
         uses: actions/checkout@v3
         with:
           repository: Unleash/client-specification
-          ref: v5.2.2
+          ref: v6.0.0
           path: client-specification
       - name: Run tests
         run: |

unleash-yggdrasil/Cargo.toml

@@ -21,13 +21,14 @@ pest_derive = "2.8.3"
 lazy_static = "1.5.0"
 semver = "1.0.27"
 convert_case = "0.8.0"
-unleash-types = {version = "0.15.21", default-features = false}
+unleash-types = {version = "0.15.22", default-features = false}
 chrono = { version = "0.4.42", default-features = false, features = ["serde", "std"] }
 dashmap = "6.1.0"
 hostname = { version = "0.4.1", optional = true }
 ipnetwork = "0.21.0"
 ahash = "0.8.12"
 hashbrown = "0.16.0"
+regex = "1.12.3"
 
 [dependencies.serde]
 features = ["derive"]

unleash-yggdrasil/src/lib.rs

@@ -953,6 +953,7 @@ mod test {
     #[test_case("18-utf8-flag-names.json"; "UTF-8 tests")]
     #[test_case("19-delta-api-hydration.json"; "Delta hydration tests")]
     #[test_case("20-delta-api-events.json"; "Delta events tests")]
+    #[test_case("21-regex-constraint-operators.json"; "Regex constraint operators")]
 
     fn run_client_spec(spec_name: &str) {
         let spec = load_spec(spec_name);

unleash-yggdrasil/src/strategy_grammar.pest

@@ -56,6 +56,8 @@ string_list_operation_without_case = {
     ends_with_ignore_case       = { "ends_with_any_ignore_case" }
     contains_any_ignore_case    = { "contains_any_ignore_case" }
 
+regex_operation = { "matches_regex_ignoring_case" | "matches_regex" }
+
 list_operation = { "in" | "not_in" }
 
 invert_operation = { "!" }
@@ -71,6 +73,7 @@ constraint = {
         | numeric_constraint
         | default_strategy_constraint
         | string_fragment_constraint
+        | regex_constraint
         | list_constraint
         | external_value
     )
@@ -82,6 +85,7 @@ constraint = {
     ip_constraint = { context_value ~ ip_contains_operation ~ string_list }
         ip_contains_operation = _{ "contains_ip" }
     string_fragment_constraint = { context_value ~ ( string_list_operation_without_case | string_list_operation ) ~ string_list }
+    regex_constraint = { context_value ~ regex_operation ~ string }
     list_constraint = { context_value ~ list_operation ~ ( numeric_list | string_list | empty_list ) }
     date_constraint = { context_value ~ ordinal_operation ~ date }
     numeric_constraint = { context_value ~ ordinal_operation ~ num }

unleash-yggdrasil/src/strategy_parsing.rs

@@ -18,6 +18,7 @@ use pest::iterators::{Pair, Pairs};
 use pest::pratt_parser::{Assoc, Op, PrattParser};
 use pest::Parser;
 use rand::Rng;
+use regex::RegexBuilder;
 use semver::Version;
 
 #[cfg(feature = "hostname")]
@@ -594,6 +595,30 @@ fn string_fragment_constraint(node: Pairs<Rule>) -> CompileResult<RuleFragment>
     }))
 }
 
+fn regex_constraint(node: Pairs<Rule>) -> CompileResult<RuleFragment> {
+    let [context_getter_node, constraint_type_node, regex_pattern_node] = drain(node)?;
+    let context_getter = context_value(context_getter_node.into_inner());
+    let regex_pattern = string(regex_pattern_node);
+
+    let mut regex_builder = RegexBuilder::new(&regex_pattern);
+
+    if constraint_type_node.as_str() == "matches_regex_ignoring_case" {
+        regex_builder.case_insensitive(true);
+    }
+
+    let Ok(regex) = regex_builder.build() else {
+        return Ok(Box::new(move |_context: &Context| false));
+    };
+
+    Ok(Box::new(move |context: &Context| {
+        if let Some(value) = context_getter(context) {
+            regex.is_match(value.as_ref())
+        } else {
+            false
+        }
+    }))
+}
+
 fn constraint(mut node: Pairs<Rule>) -> CompileResult<RuleFragment> {
     let first = node.next();
     let second = node.next();
@@ -607,6 +632,7 @@ fn constraint(mut node: Pairs<Rule>) -> CompileResult<RuleFragment> {
     let constraint = match child.as_rule() {
         Rule::date_constraint => date_constraint(child.into_inner()),
         Rule::numeric_constraint => numeric_constraint(child.into_inner()),
+        Rule::regex_constraint => regex_constraint(child.into_inner()),
         Rule::semver_constraint => semver_constraint(child.into_inner()),
         Rule::rollout_constraint => rollout_constraint(child.into_inner()), //TODO: Do we need to support inversion here?
         Rule::default_strategy_constraint => default_strategy_constraint(child.into_inner()),
@@ -1097,6 +1123,22 @@ mod tests {
         assert!(rule(&context));
     }
 
+    #[test]
+    fn evaluate_regex_match() {
+        let rule = compile_rule("user_id matches_regex \"^[^@]+@[^@]+$\"").unwrap();
+        let context = context_from_user_id("test@example.com");
+
+        assert!(rule(&context));
+    }
+
+    #[test]
+    fn evaluate_regex_match_ignoring_case() {
+        let rule = compile_rule("user_id matches_regex_ignoring_case \"^[^@]+@[^@]+$\"").unwrap();
+        let context = context_from_user_id("TEST@EXAMPLE.COM");
+
+        assert!(rule(&context));
+    }
+
     #[cfg(feature = "hostname")]
     mod hostname_tests {
         use serial_test::serial;

unleash-yggdrasil/src/strategy_upgrade.rs

@@ -326,6 +326,11 @@ fn upgrade_constraint(constraint: &Constraint) -> String {
             })
             .unwrap_or_default();
         format!("[{values}]")
+    } else if constraint.operator == Operator::RegexMatch {
+        format!(
+            "\"{}\"",
+            escape_quotes(constraint.value.as_ref().unwrap_or(&"".to_string()))
+        )
     } else {
         if constraint.operator == Operator::SemverEq
             || constraint.operator == Operator::SemverLt
@@ -370,6 +375,13 @@ fn upgrade_operator(op: &Operator, case_insensitive: bool) -> Option<String> {
                 Some("contains_any".into())
             }
         }
+        Operator::RegexMatch => {
+            if case_insensitive {
+                Some("matches_regex_ignoring_case".into())
+            } else {
+                Some("matches_regex".into())
+            }
+        }
         Operator::NumEq => Some("==".into()),
         Operator::NumGt => Some(">".into()),
         Operator::NumGte => Some(">=".into()),