BlueGit

timfa bluegit

Files

bluegit / internal / ci / expr.go

expr.go

feat: breid rules en de ingebouwde runner uit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
5fec96f0 History
expr.go 6.5 KiB Download Raw
1package ci
2
3import (
4 "regexp"
5 "strings"
6 "unicode"
7
8 "gitlab.com/Timfa/bluegit/internal/i18n"
9)
10
11// ruleParser leest een GitLab-achtige rules:if.
12// && bindt sterker dan ||. Haakjes groeperen. Een lege waarde is null.
13type ruleParser struct {
14 s string
15 i int
16 env map[string]string
17 syntax bool
18}
19
20func (p *ruleParser) parseOr() (bool, error) {
21 left, err := p.parseAnd()
22 if err != nil {
23 return false, err
24 }
25 for {
26 p.skip()
27 if !p.take("||") {
28 return left, nil
29 }
30 right, err := p.parseAnd()
31 if err != nil {
32 return false, err
33 }
34 left = left || right
35 }
36}
37
38func (p *ruleParser) parseAnd() (bool, error) {
39 left, err := p.parseCmp()
40 if err != nil {
41 return false, err
42 }
43 for {
44 p.skip()
45 if !p.take("&&") {
46 return left, nil
47 }
48 right, err := p.parseCmp()
49 if err != nil {
50 return false, err
51 }
52 left = left && right
53 }
54}
55
56func (p *ruleParser) parseCmp() (bool, error) {
57 p.skip()
58 if p.peek() == '(' {
59 p.i++
60 inner, err := p.parseOr()
61 if err != nil {
62 return false, err
63 }
64 p.skip()
65 if p.peek() != ')' {
66 return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
67 }
68 p.i++
69 return inner, nil
70 }
71 left, err := p.value()
72 if err != nil {
73 return false, err
74 }
75 p.skip()
76 op := p.operator()
77 if op == "" {
78 return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
79 }
80 right, err := p.value()
81 if err != nil {
82 return false, err
83 }
84 return compare(op, left, right, p.syntax)
85}
86
87type ruleValue struct {
88 text string
89 null bool
90 re *regexp.Regexp
91}
92
93func (p *ruleParser) value() (ruleValue, error) {
94 p.skip()
95 if p.i >= len(p.s) {
96 return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
97 }
98 switch p.s[p.i] {
99 case '$':
100 name, err := p.variable()
101 if err != nil {
102 return ruleValue{}, err
103 }
104 text := p.env[name]
105 return ruleValue{text: text, null: text == ""}, nil
106 case '"', '\'':
107 text, err := p.quoted()
108 if err != nil {
109 return ruleValue{}, err
110 }
111 return ruleValue{text: text, null: text == ""}, nil
112 case '/':
113 re, err := p.regex()
114 if err != nil {
115 return ruleValue{}, err
116 }
117 return ruleValue{re: re}, nil
118 default:
119 if p.takeWord("null") {
120 return ruleValue{null: true}, nil
121 }
122 return ruleValue{}, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
123 }
124}
125
126func (p *ruleParser) variable() (string, error) {
127 p.i++
128 if p.i < len(p.s) && p.s[p.i] == '{' {
129 p.i++
130 start := p.i
131 for p.i < len(p.s) && p.s[p.i] != '}' {
132 p.i++
133 }
134 if p.i >= len(p.s) || start == p.i {
135 return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
136 }
137 name := p.s[start:p.i]
138 p.i++
139 if !ident(name) {
140 return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
141 }
142 return name, nil
143 }
144 start := p.i
145 for p.i < len(p.s) && (isIdent(p.s[p.i])) {
146 p.i++
147 }
148 if start == p.i {
149 return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
150 }
151 return p.s[start:p.i], nil
152}
153
154func (p *ruleParser) quoted() (string, error) {
155 quote := p.s[p.i]
156 p.i++
157 var b strings.Builder
158 for p.i < len(p.s) {
159 c := p.s[p.i]
160 if c == quote {
161 p.i++
162 return b.String(), nil
163 }
164 if c == '\\' && quote == '"' && p.i+1 < len(p.s) {
165 p.i++
166 b.WriteByte(p.s[p.i])
167 p.i++
168 continue
169 }
170 if c == '$' && quote == '"' {
171 name, err := p.variable()
172 if err != nil {
173 return "", err
174 }
175 b.WriteString(p.env[name])
176 continue
177 }
178 b.WriteByte(c)
179 p.i++
180 }
181 return "", i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
182}
183
184func (p *ruleParser) regex() (*regexp.Regexp, error) {
185 p.i++
186 var b strings.Builder
187 for p.i < len(p.s) {
188 c := p.s[p.i]
189 if c == '\\' && p.i+1 < len(p.s) {
190 next := p.s[p.i+1]
191 if next == '/' {
192 b.WriteByte('/')
193 } else {
194 b.WriteByte('\\')
195 b.WriteByte(next)
196 }
197 p.i += 2
198 continue
199 }
200 if c == '/' {
201 p.i++
202 pat := b.String()
203 if p.i < len(p.s) && (p.s[p.i] == 'i' || p.s[p.i] == 'I') {
204 pat = "(?i)" + pat
205 p.i++
206 }
207 re, err := regexp.Compile(pat)
208 if err != nil {
209 return nil, i18n.E("ci.err.regex", strings.TrimSpace(p.s), err.Error())
210 }
211 return re, nil
212 }
213 b.WriteByte(c)
214 p.i++
215 }
216 return nil, i18n.E("ci.err.ruleExpr", strings.TrimSpace(p.s))
217}
218
219func (p *ruleParser) operator() string {
220 p.skip()
221 for _, op := range []string{"=~", "!~", "==", "!="} {
222 if p.take(op) {
223 return op
224 }
225 }
226 return ""
227}
228
229func (p *ruleParser) take(lit string) bool {
230 if strings.HasPrefix(p.s[p.i:], lit) {
231 p.i += len(lit)
232 return true
233 }
234 return false
235}
236
237func (p *ruleParser) takeWord(word string) bool {
238 if !strings.HasPrefix(p.s[p.i:], word) {
239 return false
240 }
241 end := p.i + len(word)
242 if end < len(p.s) && isIdent(p.s[end]) {
243 return false
244 }
245 p.i = end
246 return true
247}
248
249func (p *ruleParser) peek() byte {
250 p.skip()
251 if p.i >= len(p.s) {
252 return 0
253 }
254 return p.s[p.i]
255}
256
257func (p *ruleParser) skip() {
258 for p.i < len(p.s) && unicode.IsSpace(rune(p.s[p.i])) {
259 p.i++
260 }
261}
262
263func compare(op string, left, right ruleValue, syntax bool) (bool, error) {
264 switch op {
265 case "==":
266 if left.re != nil || right.re != nil {
267 return false, i18n.E("ci.err.ruleExpr", op)
268 }
269 if left.null || right.null {
270 return left.null && right.null, nil
271 }
272 return left.text == right.text, nil
273 case "!=":
274 if left.re != nil || right.re != nil {
275 return false, i18n.E("ci.err.ruleExpr", op)
276 }
277 if left.null || right.null {
278 return left.null != right.null, nil
279 }
280 return left.text != right.text, nil
281 case "=~", "!~":
282 if left.re != nil {
283 return false, i18n.E("ci.err.ruleExpr", op)
284 }
285 re := right.re
286 if re == nil && !right.null {
287 compiled, err := regexp.Compile(right.text)
288 if err != nil {
289 return false, i18n.E("ci.err.regex", right.text, err.Error())
290 }
291 re = compiled
292 }
293 if re == nil {
294 if syntax && right.null && right.text == "" && right.re == nil {
295 return false, nil
296 }
297 return false, i18n.E("ci.err.ruleExpr", op)
298 }
299 ok := re.MatchString(left.text)
300 if op == "!~" {
301 ok = !ok
302 }
303 return ok, nil
304 default:
305 return false, i18n.E("ci.err.ruleExpr", op)
306 }
307}
308
309// checkRule keurt de vorm goed zonder variabelen. Een patroon in een
310// variabele wordt pas bij het draaien gecompileerd.
311func checkRule(expr string) error {
312 p := &ruleParser{s: expr, env: map[string]string{}, syntax: true}
313 if _, err := p.parseOr(); err != nil {
314 return err
315 }
316 p.skip()
317 if p.i < len(p.s) {
318 return i18n.E("ci.err.ruleExpr", strings.TrimSpace(expr))
319 }
320 return nil
321}
322
323func ident(s string) bool {
324 if s == "" {
325 return false
326 }
327 for i := 0; i < len(s); i++ {
328 if !isIdent(s[i]) {
329 return false
330 }
331 }
332 return true
333}
334
335func isIdent(c byte) bool {
336 return c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
337}