Support for string constexpr evaluation

[oschwald]

As discussed in #443, I would like the ability to do something like the following in a Where:

m["msg"].Value.String().Matches(`^[A-Z]`)

Right now, it is possible to approximate this using Text.Matches, e.g.:

m["msg"].Text.Matches(`^"[A-Z]`)

However, this has the disadvantage of requiring you to handle the different kinds of string literals (or, more likely, only handle the most common case as above).

Thank you!

[ian-h-chamberlain]

If this were implemented, I would expect it to work similar to Int(), e.g.

// ExprValue describes a compile-time computable value of a matched expr.
type ExprValue struct{}

// Int returns compile-time computable int value of the expression.
// If value can't be computed, condition will fail.
func (ExprValue) Int() int { return intResult }


// Int returns compile-time computable int value of the expression.
// If value can't be computed, condition will fail.
func (ExprValue) String() string { return stringResult }

I think your example would be a little trickier in that case, since it would have to be something more like

matched, err := regexp.Match(m["msg"].Value.String())
m.Match["$msg"].Where(err != nil && matched)

I'm not sure the DSL is really capable of handling something like that, without a lot of special casing...

I was hoping for something similar to this for Suggest, although I think a similar problem presents itself, e.g.

m.Match["$msg"].Report("error").Suggest(strings.ToTitle(m["msg"].Value.String()))

Once again the use of arbitrary strings functions seems problematic, but maybe ruleguard could provide a small known set of string manipulation operations or something... Still seems like a big feature though.

[quasilyte]

The String() method should return the String type (not string) that has utility methods like Matches.
The ruleguard already has the regexp support for strings in forms of methods, we need to allow some constant string to be operated in the same way.

DSL does not support the arbitrary code.
It's just a way to describe the rules, it's not the code to be executed.