package ci import ( "regexp" "strings" "unicode" "gitlab.com/Timfa/bluegit/internal/i18n" ) // ruleParser leest een GitLab-achtige rules:if. // && bindt sterker dan ||. Haakjes groeperen. Een lege waarde is null. type ruleParser struct { s string i int env map[string]string syntax bool } func (p *ruleParser) parseOr() (bool, error) { left, err := p.parseAnd() if err != nil { return false, err } for { p.skip() if !p.take("||") { return left, nil } right, err := p.parseAnd() if err != nil { return false, err } left = left || right } } func (p *ruleParser) parseAnd() (bool, error) { left, err := p.parseCmp() if err != nil { return false, err } for { p.skip() if !p.take("&&") { return left, nil } right, err := p.parseCmp() if err != nil { return false, err } left = left && right } } func (p *ruleParser) parseCmp() (bool, error) { p.skip() if p.peek() == '(' { p.i++ inner, err := p.parseOr() if err != nil { return false, err } p.skip() if p.peek() != ')' { return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } p.i++ return inner, nil } left, err := p.value() if err != nil { return false, err } p.skip() op := p.operator() if op == "" { return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } right, err := p.value() if err != nil { return false, err } return compare(op, left, right, p.syntax) } type ruleValue struct { text string null bool re *regexp.Regexp } func (p *ruleParser) value() (ruleValue, error) { p.skip() if p.i >= len(p.s) { return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } switch p.s[p.i] { case '$': name, err := p.variable() if err != nil { return ruleValue{}, err } text := p.env[name] return ruleValue{text: text, null: text == ""}, nil case '"', '\'': text, err := p.quoted() if err != nil { return ruleValue{}, err } return ruleValue{text: text, null: text == ""}, nil case '/': re, err := p.regex() if err != nil { return ruleValue{}, err } return ruleValue{re: re}, nil default: if p.takeWord("null") { return ruleValue{null: true}, nil } return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } } func (p *ruleParser) variable() (string, error) { p.i++ if p.i < len(p.s) && p.s[p.i] == '{' { p.i++ start := p.i for p.i < len(p.s) && p.s[p.i] != '}' { p.i++ } if p.i >= len(p.s) || start == p.i { return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } name := p.s[start:p.i] p.i++ if !ident(name) { return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } return name, nil } start := p.i for p.i < len(p.s) && (isIdent(p.s[p.i])) { p.i++ } if start == p.i { return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } return p.s[start:p.i], nil } func (p *ruleParser) quoted() (string, error) { quote := p.s[p.i] p.i++ var b strings.Builder for p.i < len(p.s) { c := p.s[p.i] if c == quote { p.i++ return b.String(), nil } if c == '\\' && quote == '"' && p.i+1 < len(p.s) { p.i++ b.WriteByte(p.s[p.i]) p.i++ continue } if c == '$' && quote == '"' { name, err := p.variable() if err != nil { return "", err } b.WriteString(p.env[name]) continue } b.WriteByte(c) p.i++ } return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } func (p *ruleParser) regex() (*regexp.Regexp, error) { p.i++ var b strings.Builder for p.i < len(p.s) { c := p.s[p.i] if c == '\\' && p.i+1 < len(p.s) { next := p.s[p.i+1] if next == '/' { b.WriteByte('/') } else { b.WriteByte('\\') b.WriteByte(next) } p.i += 2 continue } if c == '/' { p.i++ pat := b.String() if p.i < len(p.s) && (p.s[p.i] == 'i' || p.s[p.i] == 'I') { pat = "(?i)" + pat p.i++ } re, err := regexp.Compile(pat) if err != nil { return nil, i18n.E("ci.err.regex", strings.TrimSpace(p.s), err.Error()) } return re, nil } b.WriteByte(c) p.i++ } return nil, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s)) } func (p *ruleParser) operator() string { p.skip() for _, op := range []string{"=~", "!~", "==", "!="} { if p.take(op) { return op } } return "" } func (p *ruleParser) take(lit string) bool { if strings.HasPrefix(p.s[p.i:], lit) { p.i += len(lit) return true } return false } func (p *ruleParser) takeWord(word string) bool { if !strings.HasPrefix(p.s[p.i:], word) { return false } end := p.i + len(word) if end < len(p.s) && isIdent(p.s[end]) { return false } p.i = end return true } func (p *ruleParser) peek() byte { p.skip() if p.i >= len(p.s) { return 0 } return p.s[p.i] } func (p *ruleParser) skip() { for p.i < len(p.s) && unicode.IsSpace(rune(p.s[p.i])) { p.i++ } } func compare(op string, left, right ruleValue, syntax bool) (bool, error) { switch op { case "==": if left.re != nil || right.re != nil { return false, i18n.E("ci.err.ruleExpr", op) } if left.null || right.null { return left.null && right.null, nil } return left.text == right.text, nil case "!=": if left.re != nil || right.re != nil { return false, i18n.E("ci.err.ruleExpr", op) } if left.null || right.null { return left.null != right.null, nil } return left.text != right.text, nil case "=~", "!~": if left.re != nil { return false, i18n.E("ci.err.ruleExpr", op) } re := right.re if re == nil && !right.null { compiled, err := regexp.Compile(right.text) if err != nil { return false, i18n.E("ci.err.regex", right.text, err.Error()) } re = compiled } if re == nil { if syntax && right.null && right.text == "" && right.re == nil { return false, nil } return false, i18n.E("ci.err.ruleExpr", op) } ok := re.MatchString(left.text) if op == "!~" { ok = !ok } return ok, nil default: return false, i18n.E("ci.err.ruleExpr", op) } } // checkRule keurt de vorm goed zonder variabelen. Een patroon in een // variabele wordt pas bij het draaien gecompileerd. func checkRule(expr string) error { p := &ruleParser{s: expr, env: map[string]string{}, syntax: true} if _, err := p.parseOr(); err != nil { return err } p.skip() if p.i < len(p.s) { return i18n.E("ci.err.ruleExpr", strings.TrimSpace(expr)) } return nil } func ident(s string) bool { if s == "" { return false } for i := 0; i < len(s); i++ { if !isIdent(s[i]) { return false } } return true } func isIdent(c byte) bool { return c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') }