whitney-coder
diff --git a/‎coderd/authz/authztest/iterator.go
Lines changed: 108 additions & 0 deletions b/‎coderd/authz/authztest/iterator.go
Lines changed: 108 additions & 0 deletions
diff --git a/‎coderd/authz/authztest/parser.go
Lines changed: 117 additions & 0 deletions b/‎coderd/authz/authztest/parser.go
Lines changed: 117 additions & 0 deletions
@@ -0,0 +1,108 @@
+package authztest
+
+type iterable interface {
+	Iterator() iterator
+}
+
+type iterator interface {
+	iterable
+
+	Next() bool
+	Permissions() Set
+	Reset()
+	ReturnSize() int
+	Size() int
+}
+
+// SetIterator is very primitive, just used to hold a place in a set.
+type SetIterator struct {
+	i   int
+	set Set
+}
+
+func union(sets ...Set) *SetIterator {
+	all := Set{}
+	for _, set := range sets {
+		all = append(all, set...)
+	}
+	return &SetIterator{
+		i:   0,
+		set: all,
+	}
+}
+
+func (si *SetIterator) Next() bool {
+	si.i++
+	return si.i < len(si.set)
+}
+
+func (si *SetIterator) Permissions() Set {
+	return Set{si.set[si.i]}
+}
+
+func (si *SetIterator) Permission() *Permission {
+	return si.set[si.i]
+}
+
+func (si *SetIterator) Reset() {
+	si.i = 0
+}
+
+func (si *SetIterator) ReturnSize() int {
+	return 1
+}
+
+func (si *SetIterator) Size() int {
+	return len(si.set)
+}
+
+func (si *SetIterator) Iterator() iterator {
+	return si
+}
+
+type productIterator struct {
+	i, j int
+	a    Set
+	b    Set
+}
+
+func product(a, b Set) *productIterator {
+	return &productIterator{
+		i: 0,
+		j: 0,
+		a: a,
+		b: b,
+	}
+}
+
+func (s *productIterator) Next() bool {
+	s.i++
+	if s.i >= len(s.a) {
+		s.i = 0
+		s.j++
+	}
+	if s.j >= len(s.b) {
+		return false
+	}
+	return true
+}
+
+func (s productIterator) Permissions() Set {
+	return Set{s.a[s.i], s.b[s.j]}
+}
+
+func (s *productIterator) Reset() {
+	s.i, s.j = 0, 0
+}
+
+func (s *productIterator) ReturnSize() int {
+	return 2
+}
+
+func (s *productIterator) Size() int {
+	return len(s.a) * len(s.b)
+}
+
+func (s *productIterator) Iterator() iterator {
+	return s
+}
@@ -0,0 +1,117 @@
+package authztest
+
+import "fmt"
+
+type Parser struct {
+	input string
+	stack []interface{}
+	grp   setGroup
+
+	setI []iterable
+}
+
+func ParseRole(grp setGroup, input string) *Role {
+	p := NewParser(grp, input)
+	p.parse()
+	return NewRole(p.setI...)
+}
+
+func Parse(grp setGroup, input string) []iterable {
+	p := NewParser(grp, input)
+	p.parse()
+	return p.setI
+}
+
+func NewParser(grp setGroup, input string) *Parser {
+
+	return &Parser{
+		grp:   grp,
+		input: input,
+		stack: make([]interface{}, 0),
+	}
+}
+
+func (p *Parser) skipSpace(ptr int) int {
+	for ptr < len(p.input) {
+		r := p.input[ptr]
+		switch r {
+		case ' ', '\t', '\n':
+			ptr++
+		default:
+			return ptr
+		}
+	}
+	return ptr
+}
+
+func (p *Parser) parse() {
+	ptr := 0
+	for ptr < len(p.input) {
+		ptr = p.skipSpace(ptr)
+		r := p.input[ptr]
+		switch r {
+		case ' ':
+			ptr++
+		case 'w', 's', 'o', 'm', 'u':
+			// Time to look ahead for the grp
+			ptr++
+			ptr = p.handleLevel(r, ptr)
+		default:
+			panic(fmt.Errorf("cannot handle '%c' at %d", r, ptr))
+		}
+	}
+}
+
+func (p *Parser) handleLevel(l uint8, ptr int) int {
+	var lg LevelGroup
+	switch l {
+	case 'w':
+		lg = p.grp.Wildcard()
+	case 's':
+		lg = p.grp.Site()
+	case 'o':
+		lg = p.grp.AllOrgs()
+	case 'm':
+		lg = p.grp.OrgMem()
+	case 'u':
+		lg = p.grp.User()
+	}
+
+	// time to look ahead. Find the parenthesis
+	var sets []Set
+	var start bool
+	var stop bool
+	for {
+		ptr = p.skipSpace(ptr)
+		r := p.input[ptr]
+		if r != '(' && !start {
+			panic(fmt.Sprintf("Expect a parenthesis at %d", ptr))
+		}
+		switch r {
+		case '(':
+			start = true
+		case ')':
+			stop = true
+		case 'p':
+			sets = append(sets, lg.Positive())
+		case 'n':
+			sets = append(sets, lg.Negative())
+		case 'a':
+			sets = append(sets, lg.Abstain())
+		case '*':
+			sets = append(sets, lg.All())
+		case 'e':
+			// Add the empty perm
+			sets = append(sets, Set{nil})
+		default:
+			panic(fmt.Errorf("unsupported '%c' for level set", r))
+		}
+		ptr++
+		if stop {
+			p.setI = append(p.setI, union(sets...))
+			return ptr
+		}
+	}
+}
+
+//func (p *Parser)