grammar.peg

{
// https://github.com/mna/pigeon

package lep
}

Input <- expr:Expr EOF { return expr, nil }
Expr <- (Or / And / Bracket / Statements)
Statements <- (Comparators / StringOps / SliceOps / ContainOps / RegexpOps)
Bracket <- _ '(' _ expr:Expr _ ')' _ { return expr, nil }
Param <- [a-zA-Z] [a-zA-Z0-9_.]* { return parseParam(c.text) }

// Values
Values <- (Null / Boolean / Float / Integer / DateTime / String)
Null <- "null" { return parseNull() }
Boolean <- ("true" / "false") { return parseBoolean(c.text) }
Float <- '-'? [0-9]+[.][0-9]+ { return parseFloat(c.text) }
Integer <- '-'? [0-9]+ { return parseInteger(c.text) }
String <- '"' [^"]* '"' { return parseString(c.text) }
DateTime <- "dt:" val:(String) { return parseDateTime(val) }

// Comparators
Comparators <- (NotEqual / Equal / GreaterThanEqual / GreaterThan / LessThanEqual / LessThan)
Equal <- left:(Param) _ "=" _ right:(Values / Param) { return parseEquals(left, right) }
NotEqual <- left:(Param) _ "!=" _ right:(Values / Param) { return parseNotEquals(left, right) }
LessThan <- left:(Param) _ "<" _ right:(Values / Param) { return parseLessThan(left, right) }
LessThanEqual <- left:(Param) _ "<=" _ right:(Values / Param) { return parseLessThanEqual(left, right) }
GreaterThan <- left:(Param) _ ">" _ right:(Values / Param) { return parseGreaterThan(left, right) }
GreaterThanEqual <- left:(Param) _ ">=" _ right:(Values / Param) { return parseGreaterThanEqual(left, right) }

// Strings
StringOps <- (StartsWith / EndsWith)
StartsWith <- left:(Param) _ "starts_with" _ right:(String / Param) { return parseStartsWith(left, right) }
EndsWith <- left:(Param) _ "ends_with" _ right:(String / Param) { return parseEndsWith(left, right) }

// Slices
SliceOps <- (InSlice / NotInSlice)
Slice <- '[' elements:(Values / ',')+ ']' { return parseSlice(elements) }
InSlice <- left:(Param) _ "in" _ right:(Slice) { return parseInSlice(left, right) }
NotInSlice <- left:(Param) _ "not_in" _ right:(Slice) { return parseNotInSlice(left, right) }

// Contains
ContainOps <- (Has / NotHas / HasAny / HasAll)
Has <- left:(Param) _ "has" _ right:(Values) { return parseHas(left, right) }
NotHas <- left:(Param) _ "not_has" _ right:(Values) { return parseNotHas(left, right) }
HasAny <- left:(Param) _ "has_any" _ right:(Slice) { return parseHasAny(left, right) }
HasAll <- left:(Param) _ "has_all" _ right:(Slice) { return parseHasAll(left, right) }

// Regular expression
RegexpOps <- (MatchRegexp / NotMatchRegexp)
Regexp <- '/' [^/]+ '/' [g|m|D|i|x|s|u|U|A|J]* { return parseRegexp(c.text) }
MatchRegexp <- left:(Param) _ "=~" _ right:(Regexp) { return parseMatchRegexp(left, right) }
NotMatchRegexp <- left:(Param) _ "!~" _ right:(Regexp) { return parseNotMatchRegexp(left, right) }

// Logic
And <- first:(Bracket / Statements) rest:(_ "&&" _ (Bracket / Statements))+ { return parseAnd(first, rest) }
Or <- first:(And / Bracket / Statements) rest:(_ "||" _ (And / Bracket / Statements))+ { return parseOr(first, rest) }

_ "whitespace" <- [ \n\t\r]*
EOF <- !.