kata-containers/regorus
1
0
Fork 0
mirror of https://github.com/microsoft/regorus.git synced 2026-08-05 02:16:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Code from github.com/anakrish/rego-rs

Browse Source 
Authored by anakrish and mingweishih

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>
This commit is contained in:
Anand Krishnamoorthi
2023-02-09 10:56:54 -08:00
parent 8f67aeecb0
commit cb0b3a1790
85 changed files with 11144 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/parser/cases/every/every.yaml
+60
View File
@@ -0,0 +1,60 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
import future.keywords
y = 8 {
every x in [2] {
x > 0
every a, b in vals { check(a) }
}
}
policy:
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
number: 8
bodies:
- query:
stmts:
- literal:
every:
key: x
domain:
array:
- number: 2
query:
stmts:
- literal:
expr:
boolexpr:
op: ">"
lhs:
var: x
rhs:
number: 0
- literal:
every:
key: a
value: b
domain:
var: vals
query:
stmts:
- literal:
expr:
call:
fcn:
var: check
params:
- var: a
tests/parser/cases/expressions/arithmetic.yaml
+40
View File
@@ -0,0 +1,40 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
x = 1 - 2 * 3 / 4 + 2
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: =
value:
arithexpr:
op: +
lhs:
arithexpr:
op: "-"
lhs:
number: 1
rhs:
arithexpr:
op: "/"
lhs:
arithexpr:
op: "*"
lhs:
number: 2
rhs:
number: 3
rhs:
number: 4
rhs:
number: 2
bodies: []
tests/parser/cases/expressions/array-compr.yaml
+209
View File
@@ -0,0 +1,209 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: case1-compr
rego: |
package test
x = {1}
y = {2}
z = [ x | y ] #, 5] # in {5}, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
arraycompr:
term:
var: x
query:
stmts:
- span: y
literal:
expr:
var: y
bodies: []
- note: case2-array
rego: |
package test
x = {1}
y = {2}
z = [ x | y, 5] # in {5}, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
array:
- binexpr:
op: "|"
lhs:
var: x
rhs:
var: y
- number: 5
bodies: []
- note: case3-compr
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = [ x | y, 5 in {5}] #, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
arraycompr:
term:
var: x
query:
stmts:
- span: y, 5 in {5}
literal:
expr:
inexpr:
key:
var: y
value:
number: 5
collection:
set:
- number: 5
bodies: []
- note: case4-array
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = [ x | y, 5 in {5}, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
array:
- binexpr:
op: "|"
lhs:
var: x
rhs:
var: y
- inexpr:
key:
number: 5
collection:
set:
- number: 5
- number: 6
bodies: []
- note: case5-array
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = [ x - {10} | y, 5 in {5}] #, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
array:
- binexpr:
op: "|"
lhs:
arithexpr:
op: "-"
lhs:
var: x
rhs:
set:
- number: 10
rhs:
var: y
- inexpr:
key:
number: 5
collection:
set:
- number: 5
bodies: []
- note: case6-compr
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = [ (x - {10}) | y, 5 in {5}] #, 6]
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
arraycompr:
term:
arithexpr:
op: "-"
lhs:
var: x
rhs:
set:
- number: 10
query:
stmts:
- literal:
expr:
inexpr:
key:
var: y
value:
number: 5
collection:
set:
- number: 5
bodies: []
tests/parser/cases/expressions/array.yaml
+108
View File
@@ -0,0 +1,108 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: all
rego: |
package test
# One item
x = {1}
# Multiple items
y = [
2.5, "abc", [ 4, `raw`, # Trailing comma
],
# Empty array
[],
# Nested empty
[[[[[]]]]]
]
policy:
- spec:
head:
compr:
refr:
var: x
assign:
span: = {1}
op: "="
value:
set:
- number: 1
bodies: --skip--
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
array:
- number: 2.5
- string: abc
- array:
- number: 4
- rawstring: raw
- array: []
- array:
- array:
- array:
- array:
- array: []
bodies: []
- note: trailing-comma
rego: |
package test
x = [1,]
y = [1,2
,]
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
array:
span: "[1,]"
values:
- number: 1
bodies: []
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
array:
span: "[1,2\n,]"
values:
- number: 1
- number: 2
bodies: []
- note: no-comma
rego: |
package test
x = [1 2]
error: expecting `]` while parsing array
- note: two-trailing-commas
rego: |
package test
x = [1,2,,]
error: expecting expression
- note: unclosed
rego: |
package test
x = [ 1
error: expecting `]` while parsing array
tests/parser/cases/expressions/bin.yaml
+64
View File
@@ -0,0 +1,64 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
# & has higher precedence than |.
# If not the following expressions would evaluate to empty set.
x = {1, 2, 3} | {2} & {4}
y = {2} & {4} | {1, 2, 3}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: =
value:
binexpr:
op: "|"
lhs:
set:
- number: 1
- number: 2
- number: 3
rhs:
binexpr:
op: "&"
lhs:
set:
- number: 2
rhs:
set:
- number: 4
bodies: []
- spec:
head:
compr:
refr:
var: y
assign:
op: =
value:
binexpr:
op: "|"
rhs:
set:
- number: 1
- number: 2
- number: 3
lhs:
binexpr:
op: "&"
lhs:
set:
- number: 2
rhs:
set:
- number: 4
bodies: []
tests/parser/cases/expressions/bool.yaml
+43
View File
@@ -0,0 +1,43 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
# bool ops have lower precedence than arithmetic operators
x = 1 + 2 > 3 - 2
# TODO: lock down
# different types against object
# different types against set
# strings etc
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: =
value:
boolexpr:
op: ">"
lhs:
arithexpr:
op: "+"
lhs:
number: 1
rhs:
number: 2
rhs:
arithexpr:
op: "-"
lhs:
number: 3
rhs:
number: 2
bodies: []
tests/parser/cases/expressions/call.yaml
+48
View File
@@ -0,0 +1,48 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
# A call in rule-ref. This creates an object.
deny[sprintf("Hello %v", ["world"])] = 1
# Trailing comma
x = inc(5,)
policy:
- spec:
head:
compr:
refr:
refbrack:
refr:
var: deny
index:
call:
fcn:
var: sprintf
params:
- string: "Hello %v"
- array:
- string: "world"
assign:
op: =
value:
number: 1
bodies: []
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
call:
fcn:
var: inc
params:
- number: 5
bodies: []
tests/parser/cases/expressions/in.yaml
+59
View File
@@ -0,0 +1,59 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
import future.keywords.in
x = 5 in [4, 5]
# in-exprs are left associative and ahve lower-precedence than bin-expr.
# The following will be parsed as
# (5 in [4, 5]) in (set() | {true})
z = 5 in [4, 5] in set() | {true}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
inexpr:
key:
number: 5
collection:
array:
- number: 4
- number: 5
bodies: []
- spec:
head:
compr:
refr:
var: z
assign:
op: "="
value:
inexpr:
key:
inexpr:
key:
number: 5
collection:
array:
- number: 4
- number: 5
collection:
binexpr:
op: "|"
lhs:
set: []
rhs:
set:
- true
bodies: []
tests/parser/cases/expressions/membership.yaml
+53
View File
@@ -0,0 +1,53 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: basic
rego: |
package test
import future.keywords.in
# key, value in collection
x = 0, 5 in [5]
# Chained in-exprs
y = 0, 5 in c in d
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
inexpr:
key:
number: 0
value:
number: 5
collection:
array:
- number: 5
bodies: []
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
inexpr:
key:
inexpr:
key:
number: 0
value:
number: 5
collection:
var: c
collection:
var: d
bodies: []
tests/parser/cases/expressions/object.yaml
+163
View File
@@ -0,0 +1,163 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: all
rego: |
package test
import future.keywords.in
# Empty object
x = {}
# Single field
y = {
"a" : 5
}
# Multiple fields
z = {
"a" : 5,
"b" : [ 1, 2, 3 ],
"c" : { 4, 5, 6 },
"d" : {
"a" : 5,
"b" : set()
}
# array as key
, [1,
2,
3] : 4,
# set as key
{ 1 } : 2,
# Object as key
{
"a" : 1,
"b" : 2, # Trailing comma
} : `hello,
world`
# Null, boolean
, null: false,
true : true,
# Only single var in is supported as value
"p" : "q", "r" in "d" : "e"
}
policy:
- spec:
span: x = {}
head:
compr:
span: x = {}
refr:
var: x
assign:
span: = {}
op: =
value:
object:
fields: []
bodies: []
- spec:
head:
compr:
refr:
var: y
assign:
op: =
value:
object:
fields:
- key:
string: a
value:
number: 5
bodies: []
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
object:
fields:
- key:
string: a
value:
number: 5
- key:
string: b
value:
array:
- number: 1
- number: 2
- number: 3
- key:
string: c
value:
set:
- number: 4
- number: 5
- number : 6
- key:
string: d
value:
object:
fields:
- key:
string: a
value:
number: 5
- key:
string: b
value:
set: []
- key:
array:
- number: 1
- number: 2
- number: 3
value:
number: 4
- key:
set:
- number: 1
value:
number: 2
- key:
object:
fields:
- key:
string: a
value:
number: 1
- key:
string: b
value:
number: 2
value:
rawstring: "hello,\n world"
- key: null
value: false
- key: true
value: true
- key:
string: p
value:
string: q
- key:
inexpr:
key:
string: r
collection:
string: d
value:
string: e
bodies: []
tests/parser/cases/expressions/set-compr.yaml
+209
View File
@@ -0,0 +1,209 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: case1-compr
rego: |
package test
x = {1}
y = {2}
z = { x | y } #, 5} # in {5}, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
setcompr:
term:
var: x
query:
stmts:
- span: y
literal:
expr:
var: y
bodies: []
- note: case2-set
rego: |
package test
x = {1}
y = {2}
z = { x | y, 5} # in {5}, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
set:
- binexpr:
op: "|"
lhs:
var: x
rhs:
var: y
- number: 5
bodies: []
- note: case3-compr
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = { x | y, 5 in {5}} #, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
setcompr:
term:
var: x
query:
stmts:
- span: y, 5 in {5}
literal:
expr:
inexpr:
key:
var: y
value:
number: 5
collection:
set:
- number: 5
bodies: []
- note: case4-set
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = { x | y, 5 in {5}, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
set:
- binexpr:
op: "|"
lhs:
var: x
rhs:
var: y
- inexpr:
key:
number: 5
collection:
set:
- number: 5
- number: 6
bodies: []
- note: case5-set
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = { x - {10} | y, 5 in {5}} #, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
set:
- binexpr:
op: "|"
lhs:
arithexpr:
op: "-"
lhs:
var: x
rhs:
set:
- number: 10
rhs:
var: y
- inexpr:
key:
number: 5
collection:
set:
- number: 5
bodies: []
- note: case6-compr
rego: |
package test
import future.keywords.in
x = {1}
y = {2}
z = { (x - {10}) | y, 5 in {5}} #, 6}
policy:
- --skip--
- --skip--
- spec:
head:
compr:
refr:
var: z
assign:
op: =
value:
setcompr:
term:
arithexpr:
op: "-"
lhs:
var: x
rhs:
set:
- number: 10
query:
stmts:
- literal:
expr:
inexpr:
key:
var: y
value:
number: 5
collection:
set:
- number: 5
bodies: []
tests/parser/cases/expressions/set.yaml
+112
View File
@@ -0,0 +1,112 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: all
rego: |
package test
# One item
x = {1}
# Multiple items
y = {
2.5, "abc", { 4, `raw`
},
# Empty set has a special syntax
set( ),
# Nested empty
{{{{{}}}}}
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
span: = {1}
op: "="
value:
set:
- number: 1
bodies: --skip--
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
set:
- number: 2.5
- string: abc
- set:
- number: 4
- rawstring: raw
- set: []
- set:
- set:
- set:
- set:
- object:
span: "{}"
fields: []
bodies: []
- note: trailing-comma
rego: |
package test
x = {1,}
y = {1,2
,}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
set:
span: "{1,}"
values:
- number: 1
bodies: []
- spec:
head:
compr:
refr:
var: y
assign:
op: "="
value:
set:
span: "{1,2\n,}"
values:
- number: 1
- number: 2
bodies: []
- note: no-comma
rego: |
package test
x = {1 2}
error: expecting `}` while parsing set
- note: two-trailing-commas
rego: |
package test
x = {1,2,,}
error: expecting expression
- note: unclosed
rego: |
package test
x = { 1
error: expecting `}` while parsing set
tests/parser/cases/import/future.yaml
+154
View File
@@ -0,0 +1,154 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: namespace
rego: |
package test
import future.keywords
imports:
- span: import future.keywords
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
- note: all
rego: |
package test
import future.keywords.contains import future.keywords.every
import future.keywords.if
import
future.keywords.in
imports:
- span: import future.keywords.contains
refr:
refdot:
span: future.keywords.contains
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
field: contains
- span: import future.keywords.every
refr:
refdot:
span: future.keywords.every
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
field: every
- span: import future.keywords.if
refr:
refdot:
span: future.keywords.if
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
field: if
- span: "import\nfuture.keywords.in"
refr:
refdot:
span: future.keywords.in
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
field: in
- note: bracket
rego: |
package test
import future["keywords"]["contains"] import future.keywords["every"]
import
future["keywords"].if
imports:
- span: import future["keywords"]["contains"]
refr:
refbrack:
span: future["keywords"]["contains"]
refr:
refbrack:
span: future["keywords"]
refr:
var: future
index:
string: keywords
index:
string: contains
- span: import future.keywords["every"]
refr:
refbrack:
span: future.keywords["every"]
refr:
refdot:
span: future.keywords
refr:
var: future
field: keywords
index:
string: every
- span: "import\nfuture[\"keywords\"].if"
refr:
refdot:
span: future["keywords"].if
refr:
refbrack:
span: future["keywords"]
refr:
var: future
index:
string: keywords
field: if
- note: as
rego: |
package test
import future.keywords.in as on
error: "`future` imports cannot be aliased"
- note: shadow
rego: |
package test
import future.keywords
import future["keywords"]
error: "this import shadows previous import of `contains`"
- note: shadow/1
rego: |
package test
import future.keywords
import future.keywords.if
error: "this import shadows previous import of `if`"
- note: shadow/2
rego: |
package test
import future.keywords.if
import future.keywords
error: "this import shadows previous import of `if`"
- note: in-as-var
rego: |
package test
import future.keywords.if
in = 5
- note: in-as-var-imported
rego: |
package test
import future.keywords.in
in = 5
error: unexpected keyword `in`
tests/parser/cases/import/import.yaml
+308
View File
@@ -0,0 +1,308 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: data
rego: |
package test
import data
import input
imports:
- span: import data
refr:
var: data
- span: import input
refr:
var: input
- note: input
rego: |
package test
import input
imports:
- span: import input
refr:
var: input
- note: dot
rego: |
package test
import input.a
import data.b
imports:
- span: import input.a
refr:
refdot:
refr:
var: input
field: a
- span: import data.b
refr:
refdot:
refr:
var: data
field: b
- note: bracket
rego: |
package test
import input["a"]
import data["b"]
imports:
- span: import input["a"]
refr:
refbrack:
refr:
var: input
index:
string: a
- span: import data["b"]
refr:
refbrack:
refr:
var: data
index:
string: b
- note: multi-dot
rego: |
package test
import input.a.b
import data.c.d
imports:
- span: import input.a.b
refr:
refdot:
span: input.a.b
refr:
refdot:
span: input.a
refr:
var: input
field: a
field: b
- span: import data.c.d
refr:
refdot:
span: data.c.d
refr:
refdot:
span: data.c
refr:
var: data
field: c
field: d
policy: []
- note: complex
rego: |
package test
import input["b.c"].d["e.f"].g
import data.a["b.c"].d["e.f"]
package: --skip--
imports:
- span: import input["b.c"].d["e.f"].g
refr:
refdot:
span: input["b.c"].d["e.f"].g
refr:
refbrack:
span: input["b.c"].d["e.f"]
refr:
refdot:
span: input["b.c"].d
refr:
refbrack:
span: input["b.c"]
refr:
var: input
index:
string: b.c
field: d
index:
string: e.f
field: g
- span: import data.a["b.c"].d["e.f"]
refr:
refbrack:
span: data.a["b.c"].d["e.f"]
refr:
refdot:
span: data.a["b.c"].d
refr:
refbrack:
span: data.a["b.c"]
refr:
refdot:
span: data.a
refr:
var: data
field: a
index:
string: b.c
field: d
index:
string: e.f
- note: same-line
rego: package test import input.a["b"] import data["c"].d
package:
span: package test
refr:
var: test
imports:
- span: import input.a["b"]
refr:
refbrack:
span: input.a["b"]
refr:
refdot:
span: input.a
refr:
var: input
field: a
index:
string: b
- span: import data["c"].d
refr:
refdot:
span: data["c"].d
refr:
refbrack:
span: data["c"]
refr:
var: data
index:
string: c
field: d
- note: as
rego: |
package test
import input.x as y
imports:
- span: import input.x as y
refr:
refdot:
span: input.x
refr:
var: input
field: x
as: y
- note: as/newline
rego: |
package test
import
input.x
as
y
imports:
- span: "import\ninput.x\nas\ny"
refr:
refdot:
span: input.x
refr:
var: input
field: x
as: y
- note: missing-ref
rego: |
package test
import ( a)
error: expecting identifier
- note: missing-ref-1
rego: |
package test
import ["a"]
error: expecting identifier
- note: invalid-beginning
rego: |
package test
import foo
error: "import path must begin with one of: {data, future, input}"
- note: invalid-beginning-1
rego: |
package test
import foo.bar
error: "import path must begin with one of: {data, future, input}"
- note: missing-field-1
rego: |
package test
import data.a.
error: expecting identifier
- note: missing-field-2
rego: |
package test
import data.a.b.
error: expecting identifier
- note: space-after-dot
rego: |
package test
import input. a
error: invalid whitespace between . and identifier
- note: space-before-dot
rego: |
package test
import input .a.b
error: invalid whitespace before .
- note: space-after-lbracket
rego: package test import a ["b"]
error: invalid whitespace before [
- note: non-string-index
rego: package test import a[1]
error: expected string
- note: shadow
rego:
package test
import data.x import data.y import data["x"]
error: import shadows following import defined earlier
- note: keyword/else
rego:
package test
import data.x as else
error: "unexpected keyword `else`"
- note: keyword/as
rego:
package test
import data.x as as
error: "unexpected keyword `as`"
- note: as/_
rego:
package test
import data.x as _
error: "`_` cannot be used as alias"
- note: as/_
rego:
package test
import data.x as 1
error: expecting identifier
- note: as/eof
rego:
package test
import data.x as
error: expecting identifier
- note: as/multiple
rego:
package test
import data.x as y
import data.y as y
error: import shadows following import defined earlier
tests/parser/cases/package/package.yaml
+129
View File
@@ -0,0 +1,129 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: single-char
rego: package a
package:
span: package a
refr:
var: a
- note: simple
rego: package test
package:
span: package test
refr:
var: test
- note: dot
rego: package a.b
package:
span: package a.b
refr:
refdot:
span: a.b
refr:
var: a
field: b
- note: multi-dot
rego: package a.b.c
package:
span: package a.b.c
refr:
refdot:
span: a.b.c
refr:
refdot:
span: a.b
refr:
var: a
field: b
field: c
- note: bracket
rego: package a["b"]
package:
span: package a["b"]
refr:
refbrack:
span: a["b"]
refr:
var: a
index:
string: b
- note: multi-bracket
rego: package a["b"]["c.d"]
package:
span: package a["b"]["c.d"]
refr:
refbrack:
span: a["b"]["c.d"]
refr:
refbrack:
span: a["b"]
refr:
var: a
index:
string: b
index:
string: c.d
- note: complex
rego: package a["b.c"].d["e.f"].g
package:
span: package a["b.c"].d["e.f"].g
refr:
refdot:
span: a["b.c"].d["e.f"].g
refr:
refbrack:
span: a["b.c"].d["e.f"]
refr:
refdot:
span: a["b.c"].d
refr:
refbrack:
span: a["b.c"]
refr:
var: a
index:
string: "b.c"
field: d
index:
string: e.f
field: g
- note: missing-package-keyword
rego: packge a
error: expecting `package`
- note: missing-var
rego: package 5
error: expecting identifier
- note: missing-var-1
rego: package (
error: expecting identifier
- note: missing-field
rego: package a.b.
error: expecting identifier
- note: space-after-dot
rego: package a. b
error: invalid whitespace between . and identifier
- note: space-before-dot
rego: package a .b
error: invalid whitespace before .
- note: space-after-lbracket
rego: package a ["b"]
error: invalid whitespace before [
- note: non-string-index
rego: package a[1]
error: expected string
tests/parser/cases/rules/basic.yaml
+44
View File
@@ -0,0 +1,44 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: same-line-no-body
rego: |
package test
add(x, y) := 5 sub(x, y) = 5
package: --skip--
imports:
policy:
- spec:
span: add(x, y) := 5
head:
func:
span: add(x, y) := 5
refr:
var: add
args:
- var: x
- var: y
assign:
span: := 5
op: :=
value:
number: 5
bodies: []
- spec:
span: sub(x, y) = 5
head:
func:
span: sub(x, y) = 5
refr:
var: sub
args:
- var: x
- var: y
assign:
span: = 5
op: =
value:
number: 5
bodies: []
tests/parser/cases/rules/else.yaml
+250
View File
@@ -0,0 +1,250 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: no-query
rego: |
package test
x = 10 else {
true
}
error: unexpected keyword `else`
- note: no-query
rego: |
package test
x = 10 {
false
} {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
false
- query:
stmts:
- literal:
expr:
true
- note: no-else
rego: |
package test
x = 10 {
false
} {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
false
- query:
stmts:
- literal:
expr:
true
- note: if-no-else
rego: |
package test
import future.keywords.if
x = 10 if {
false
} {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
false
- query:
stmts:
- literal:
expr:
true
- note: rule-named-if
rego: |
package test
x = 10 if {
false
} {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies: []
- spec:
head:
compr:
refr:
var: if
bodies:
- query:
stmts:
- literal:
expr:
false
- query:
stmts:
- literal:
expr:
true
- note: query-else
rego: |
package test
x = 10 {
false
} else {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
false
- query:
stmts:
- literal:
expr:
true
- note: if-literal-else
rego: |
package test
import future.keywords.if
x = 10 if 1 < 0 else {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
boolexpr:
op: "<"
lhs:
number: 1
rhs:
number: 0
- query:
stmts:
- literal:
expr:
true
- note: if-literal-else-assign
rego: |
package test
import future.keywords.if
# This will evaluate to 10
x = 10 if 1 < 0 else := 20 {
true
}
policy:
- spec:
head:
compr:
refr:
var: x
assign:
op: "="
value:
number: 10
bodies:
- query:
stmts:
- literal:
expr:
boolexpr:
op: "<"
lhs:
number: 1
rhs:
number: 0
- assign:
op: ":="
value:
number: 20
query:
stmts:
- literal:
expr:
true
tests/parser/cases/rules/set.yaml
+135
View File
@@ -0,0 +1,135 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: contains
rego: |
package test
import future.keywords
deny.a contains 0, "bar" in ["bar1"] if true
policy:
- spec:
head:
set:
refr:
refdot:
refr:
var: deny
field: a
key:
inexpr:
key:
number: 0
value:
string: bar
collection:
array:
- string: bar1
bodies:
- query:
stmts:
- literal:
expr:
true
- note: old-syntax
rego: |
package test
import future.keywords.if
# The following are not sets
x1 if true
x2 { true }
# The following are sets
y.a { true }
y["b"] { true }
# The following are not sets
z.a if { true }
z["b"] if { true }
policy:
- spec:
head:
compr:
refr:
var: x1
bodies:
- query:
stmts:
- literal:
expr:
true
- spec:
head:
compr:
refr:
var: x2
bodies:
- query:
stmts:
- literal:
expr:
true
- spec:
head:
set:
refr:
refdot:
refr:
var: y
field: a
bodies:
- query:
stmts:
- literal:
expr:
true
- spec:
head:
set:
refr:
var: y
key:
string: b
bodies:
- query:
stmts:
- literal:
expr:
true
- spec:
head:
compr:
refr:
refdot:
refr:
var: z
field: a
bodies:
- query:
stmts:
- literal:
expr:
true
- spec:
head:
compr:
refr:
refbrack:
refr:
var: z
index:
string: b
bodies:
- query:
stmts:
- literal:
expr:
true
tests/parser/cases/some/some.in.yaml
+226
View File
@@ -0,0 +1,226 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: all
rego: |
package test
import future.keywords.in
x = y {
# Empty set. This evaluates to false.
some a in {1}
# Key, value combo
some a
, b in r
# Key, value combo can be non-vars
some 5, x in array
some "hello", "world" in map
some p, q in { r |
some a, b in d
}
}
policy:
- spec:
head: --skip--
bodies:
- query:
stmts:
- span: some a in {1}
literal:
some-decl:
key:
var: a
collection:
set:
- number: 1
- span: "some a\n , b in r"
literal:
some-decl:
key:
var: a
value:
var: b
collection:
var: r
- span: "some 5, x in array"
literal:
some-decl:
key:
number: 5
value:
var: x
collection:
var: array
- span: "some \"hello\", \"world\" in map"
literal:
some-decl:
key:
string: hello
value:
string: world
collection:
var: map
- literal:
some-decl:
key:
var: p
value:
var: q
collection:
setcompr:
term:
var: r
query:
stmts:
- literal:
some-decl:
key:
var: a
value:
var: b
collection:
var: d
- note: unimported-in
rego: |
package test
x = y {
some a in b
}
error: expecting `}` while parsing query
- note: more-refs
rego: |
package test
import future.keywords.in
x = y {
some a, b, c in d
}
error: encountered `c` while expecting `in`
- note: eof
rego: |
package test
import future.keywords.in
x = y {
some a, b in
error: expecting expression
- note: missing-expr
rego: |
package test
import future.keywords.in
x = y {
some a, b in
}
error: expecting expression
- note: missing-comma
rego: |
package test
import future.keywords.in
x = y {
some a b in c
}
error: expecting `}` while parsing query
- note: same-line
rego: |
package test
x = y{
some a b in {4, 5}
[1, 2, 3][a] == 3
y = a
}
error: expecting `}` while parsing query
- note: multi-line-parsed as membership
rego: |
package test
import future.keywords.in
b := 5
x = y{
some a
b in {4, 5}
# The following [ starting a line ought to get
# parsed as a literal statement and not raise errors
# regarding gap from previous refr.
[1, 2, 3][a] == 3
y = a
}
policy:
- spec:
head:
compr:
span: b := 5
refr:
var: b
assign:
op: :=
value:
number: 5
bodies: []
- spec:
head:
compr:
span: x = y
refr:
var: x
assign:
op: =
value:
var: y
bodies:
- query:
stmts:
- literal:
some-vars:
span: some a
vars:
- a
- literal:
expr:
inexpr:
span: b in {4, 5}
key:
var: b
collection:
set:
- number: 4
- number: 5
- literal:
expr:
boolexpr:
span: "[1, 2, 3][a] == 3"
op: ==
lhs:
refbrack:
span: "[1, 2, 3][a]"
refr:
array:
- number: 1
- number: 2
- number: 3
index:
var: a
rhs:
number: 3
- literal:
expr:
assignexpr:
span: y = a
op: =
lhs:
var: y
rhs:
var: a
tests/parser/cases/some/some.vars.yaml
+74
View File
@@ -0,0 +1,74 @@
# Copyright (c) Rego-Rs Authors.
# Licensed under the Apache 2.0 license.
cases:
- note: single-multi-vars
rego: |
package test
x = y {
# Single var
some a
# Multiple var. With and without spaces.
some
d,e,
f
}
policy:
- spec:
head: --skip--
bodies:
- query:
stmts:
- span: some a
literal:
some-vars:
span: some a
vars:
- a
- span: "some\n d,e,\n f"
literal:
some-vars:
span: "some\n d,e,\n f"
vars: [d, e, f]
- note: same-line-error
rego: |
package test
x = y {
some a some b
}
error: expecting `}` while parsing query
- note: keyword
rego: |
package test
x = y {
some as
}
error: unexpected keyword `as`
- note: top-level
rego: |
package test
x = some y
error: unexpected keyword `some`
- note: top-level1
rego: |
package test
some y
error: unexpected keyword `some`
- note: some-in-set
rego: |
package test
x = { some y }
error: unexpected keyword `some`
- note: non-var
rego: |
package test
x = y {
some a, 5
}
error: encountered `5` while expecting identifier