-
Notifications
You must be signed in to change notification settings - Fork 782
/
field_parser.go
90 lines (78 loc) · 2.28 KB
/
field_parser.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package parser
import (
"github.com/benthosdev/benthos/v4/internal/bloblang/field"
)
func intoStaticResolver(p Func[string]) Func[field.Resolver] {
return func(input []rune) Result[field.Resolver] {
res := p(input)
if res.Err != nil {
return Fail[field.Resolver](res.Err, input)
}
return Success[field.Resolver](field.StaticResolver(res.Payload), res.Remaining)
}
}
var interpStart = Term("${!")
func aFunction(pCtx Context) Func[field.Resolver] {
pattern := TakeOnly(2, Sequence(
strToQuery(interpStart),
strToQuery(Optional(SpacesAndTabs)),
MustBe(queryParser(pCtx)),
strToQuery(Optional(SpacesAndTabs)),
strToQuery(MustBe(Expect(charSquigClose, "end of expression"))),
))
return func(input []rune) Result[field.Resolver] {
res := pattern(input)
if res.Err != nil {
return Fail[field.Resolver](res.Err, input)
}
return Success[field.Resolver](field.NewQueryResolver(res.Payload), res.Remaining)
}
}
var (
interpEscapedStart = Term("${{!")
interpEscapedEnd = Term("}}")
untilInterpEscapedEnd = UntilTerm("}}")
)
var escapedBlock = func() Func[field.Resolver] {
pattern := TakeOnly(1, Sequence(
interpEscapedStart,
MustBe(Expect(untilInterpEscapedEnd, "end of escaped expression")),
interpEscapedEnd,
))
return func(input []rune) Result[field.Resolver] {
res := pattern(input)
if res.Err != nil {
return Fail[field.Resolver](res.Err, input)
}
return Success[field.Resolver](field.StaticResolver("${!"+res.Payload+"}"), res.Remaining)
}
}()
//------------------------------------------------------------------------------
func parseFieldResolvers(pCtx Context, expr string) ([]field.Resolver, *Error) {
var resolvers []field.Resolver
p := OneOf(
escapedBlock,
aFunction(pCtx),
intoStaticResolver(charDollar),
intoStaticResolver(NotChar('$')),
)
remaining := []rune(expr)
for len(remaining) > 0 {
res := p(remaining)
if res.Err != nil {
return nil, res.Err
}
remaining = res.Remaining
resolvers = append(resolvers, res.Payload)
}
return resolvers, nil
}
// ParseField attempts to parse a field expression.
func ParseField(pCtx Context, expr string) (*field.Expression, *Error) {
resolvers, err := parseFieldResolvers(pCtx, expr)
if err != nil {
return nil, err
}
e := field.NewExpression(resolvers...)
return e, nil
}