topdown: support glob.match without delimiters (#4933)

Using null for delimiters disables delimiters in glob matching. Preferable over regex on some cases for performance reasons.

Fixes #4923.

Signed-off-by: vinhph0906 <vinhph0906@gmail.com>
Co-authored-by: Stephan Renatus <stephan.renatus@gmail.com>

ast/builtins.go

@@ -2604,7 +2604,10 @@ var GlobMatch = &Builtin{
 	Decl: types.NewFunction(
 		types.Args(
 			types.Named("pattern", types.S),
-			types.Named("delimiters", types.NewArray(nil, types.S)).Description("glob pattern delimiters, e.g. `[\".\", \":\"]`, defaults to `[\".\"]` if unset."),
+			types.Named("delimiters", types.NewAny(
+				types.NewArray(nil, types.S),
+				types.NewNull(),
+			)).Description("glob pattern delimiters, e.g. `[\".\", \":\"]`, defaults to `[\".\"]` if unset. If `delimiters` is `null`, glob match without delimiter."),
 			types.Named("match", types.S),
 		),
 		types.Named("result", types.B).Description("true if `match` can be found in `pattern` which is separated by `delimiters`"),

builtin_metadata.json

@@ -3677,9 +3677,9 @@
         "type": "string"
       },
       {
-        "description": "glob pattern delimiters, e.g. `[\".\", \":\"]`, defaults to `[\".\"]` if unset.",
+        "description": "glob pattern delimiters, e.g. `[\".\", \":\"]`, defaults to `[\".\"]` if unset. If `delimiters` is `null`, glob match without delimiter.",
         "name": "delimiters",
-        "type": "array[string]"
+        "type": "any\u003cnull, array[string]\u003e"
       },
       {
         "name": "match",

capabilities.json

@@ -894,10 +894,18 @@
             "type": "string"
           },
           {
-            "dynamic": {
-              "type": "string"
-            },
-            "type": "array"
+            "of": [
+              {
+                "type": "null"
+              },
+              {
+                "dynamic": {
+                  "type": "string"
+                },
+                "type": "array"
+              }
+            ],
+            "type": "any"
           },
           {
             "type": "string"

docs/content/policy-reference.md

@@ -337,6 +337,7 @@ The following table shows examples of how ``glob.match`` works:
 | -------- | ---------- | ----------- |
 | ``output := glob.match("*.github.com", [], "api.github.com")`` | ``true`` | A glob with the default ``["."]`` delimiter. |
 | ``output := glob.match("*.github.com", [], "api.cdn.github.com")`` | ``false`` | A glob with the default ``["."]`` delimiter. |
+| ``output := glob.match("*hub.com", null, "api.cdn.github.com")`` | ``true`` | A glob without delimiter. |
 | ``output := glob.match("*:github:com", [":"], "api:github:com")`` | ``true`` | A glob with delimiters ``[":"]``. |
 | ``output := glob.match("api.**.com", [], "api.github.com")`` | ``true`` | A super glob. |
 | ``output := glob.match("api.**.com", [], "api.cdn.github.com")`` | ``true`` | A super glob. |

test/cases/testdata/globmatch/test-globmatch-0159.yaml

@@ -0,0 +1,29 @@
+cases:
+- data: {}
+  modules:
+  - |
+    package generated
+
+    p[x] {
+      glob.match("*", null, "foo.bar", x)
+    }
+  note: globmatch/glob match single without default delimiter
+  query: data.generated.p = x
+  sort_bindings: true
+  want_result:
+  - x:
+    - true
+- data: {}
+  modules:
+  - |
+    package generated
+
+    p[x] {
+      glob.match("foo*", null, "foo.bar", x)
+    }
+  note: globmatch/glob match single without default delimiter, glob non-empty
+  query: data.generated.p = x
+  sort_bindings: true
+  want_result:
+  - x:
+    - true

topdown/glob.go

@@ -18,16 +18,22 @@ func builtinGlobMatch(a, b, c ast.Value) (ast.Value, error) {
 	if err != nil {
 		return nil, err
 	}
+	var delimiters []rune
+	switch b.(type) {
+	case ast.Null:
+		delimiters = []rune{}
+	case *ast.Array:
+		delimiters, err = builtins.RuneSliceOperand(b, 2)
+		if err != nil {
+			return nil, err
+		}
 
-	delimiters, err := builtins.RuneSliceOperand(b, 2)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(delimiters) == 0 {
-		delimiters = []rune{'.'}
+		if len(delimiters) == 0 {
+			delimiters = []rune{'.'}
+		}
+	default:
+		return nil, builtins.NewOperandTypeErr(2, b, "array", "null")
 	}
-
 	match, err := builtins.StringOperand(c, 3)
 	if err != nil {
 		return nil, err

wasm/src/glob-compiler.cc

@@ -128,7 +128,7 @@ std::string glob_translate(const char *glob, size_t n, const std::vector<std::st
 
     if (delimiters.empty())
     {
-        single_mark = "[^\\.]";
+        single_mark = ".";
     } else {
         single_mark = "[^";
 

wasm/src/glob.cc

@@ -53,7 +53,9 @@ static glob_cache* cache()
 OPA_BUILTIN
 opa_value *opa_glob_match(opa_value *pattern, opa_value *delimiters, opa_value *match)
 {
-    if (opa_value_type(pattern) != OPA_STRING || opa_value_type(delimiters) != OPA_ARRAY || opa_value_type(match) != OPA_STRING)
+    if (opa_value_type(pattern) != OPA_STRING ||
+        (opa_value_type(delimiters) != OPA_ARRAY && opa_value_type(delimiters) != OPA_NULL) ||
+        opa_value_type(match) != OPA_STRING)
     {
         return NULL;
     }
@@ -75,6 +77,15 @@ opa_value *opa_glob_match(opa_value *pattern, opa_value *delimiters, opa_value *
         v.push_back(std::string(s->v, s->len));
         prev = curr;
     }
+
+    // NOTE(sr): If we're passed an empty array, use "." as default delimiter.
+    //           If we're passed OPA_NULL, use no delimiter; but separate glob parts by '.*'
+    if (opa_value_type(delimiters) == OPA_ARRAY) {
+        if (v.empty())
+        {
+            v.push_back(std::string("."));
+        }
+    }
 
     glob_cache *c = cache();
     cache_key key = cache_key(std::string(p->v, p->len), v);

wasm/tests/test-glob.cc

@@ -234,6 +234,7 @@ void test_glob_translate()
         for (int i = 0; i < sizeof(delimiters)/sizeof(const char*); i++) { \
             v.push_back(delimiters[i]);                                 \
         }                                                               \
+        if (v.empty()) { v.push_back(std::string(".")); }               \
         glob_translate(pattern, strlen(pattern), v, &re2);              \
         test_str_eq(test_case, expected, re2.c_str());                  \
         re2::RE2::Options options;                                      \