Liquid template expression syntax

assignment_expression.bnf

expression  : ID "=" filtered

filtered    : left { "|" filter } 

left        : literal
            | path
            | range

literal     : FLOAT 
            | INTEGER
            | STRING
            | TRUE
            | FALSE
            | NIL
            | NULL
            | EMPTY
            | BLANK

path        : ID { prop }

prop        : bracketed
            | dotted

bracketed   : "[" elem "]"

dotted      : "." ID

elem        : path
            | INTEGER
            | STRING

range       : "(" rangearg DOUBLEDOT rangearg ")"

rangearg    : INTEGER
            | FLOAT
            | path

filter      : ID [ ":" args ]

args        : arg { "," arg }

arg         : parg
            | kwarg

parg        : literal
            | path

kwarg       : ID ":" parg

boolean_expression.bnf

expr        : object [ comp ] { logic_op expr }

comp        : comp_op object

logic_op    : "and"
            | "or"

comp_op     : "=="
            | "<"
            | ">"
            | "<="
            | ">="
            | "!="
            | "<>"
            | "contains"

object      : literal
            | path
            | range

literal     : FLOAT 
            | INTEGER
            | STRING
            | TRUE
            | FALSE
            | NIL
            | NULL
            | EMPTY
            | BLANK

path        : ID { prop }

prop        : bracketed
            | dotted

bracketed   : "[" elem "]"

dotted      : "." ID

elem        : path
            | INTEGER
            | STRING

range       : "(" range_arg DOUBLEDOT range_arg ")"

range_arg   : INTEGER
            | FLOAT
            | path

filtered_expression.bnf

expr        : left { "|" filter } 

left        : literal
            | path
            | range

literal     : FLOAT 
            | INTEGER
            | STRING
            | TRUE
            | FALSE
            | NIL
            | NULL
            | EMPTY
            | BLANK

path        : ID { prop }

prop        : bracketed
            | dotted

bracketed   : "[" elem "]"

dotted      : "." ID

elem        : path
            | INTEGER
            | STRING

range       : "(" rangearg DOUBLEDOT rangearg ")"

rangearg    : INTEGER
            | FLOAT
            | path

filter      : ID [ ":" args ]

args        : arg { "," arg }

arg         : parg
            | kwarg

parg        : literal
            | path

kwarg       : ID ":" parg

inline_if_expression.bnf

expression  : filtered [ condition ]

filtered    : object { "|" filter }

condition   : "if" boolean [ alternative ] [ tailfilters ]

boolean     : object [ comparison ] { logic_op boolean }

alternative : "else" filtered

tailfilters : "||" filter { "|" filter }

comparison  : comp_op object

logic_op    : "and"
            | "or"

comp_op     : "=="
            | "<"
            | ">"
            | "<="
            | ">="
            | "!="
            | "<>"
            | "contains"

object      : literal
            | path
            | range

literal     : FLOAT 
            | INTEGER
            | STRING
            | TRUE
            | FALSE
            | NIL
            | NULL
            | EMPTY
            | BLANK

path        : ID { prop }

prop        : bracketed
            | dotted

bracketed   : "[" elem "]"

dotted      : "." ID

elem        : path
            | INTEGER
            | STRING

range       : "(" rangearg DOUBLEDOT rangearg ")"

rangearg    : INTEGER
            | FLOAT
            | path

filter      : ID [ ":" args ]

args        : arg { "," arg }

arg         : parg
            | kwarg

parg        : literal
            | path

kwarg       : ID ":" parg

loop_expression.bnf

expr        : ID "in" iterable { option }

iterable    : path
            | range

option      : limit
            | offset
            | "reversed"

limit       : "limit" ":" limitarg

offset      : "offset" ":" offsetarg

limitarg    : INTEGER
            | path

offsetarg   : INTEGER
            | path
            | "continue"

path        : ID { prop }

prop        : bracketed
            | dotted

bracketed   : "[" elem "]"

dotted      : "." ID

elem        : path
            | INTEGER
            | STRING

range       : "(" rangearg DOUBLEDOT rangearg ")"

rangearg    : INTEGER
            | FLOAT
            | path

The BNF-like syntax used here is that favoured by the SLY project, which is no longer under active development.

Note that the inline if expression described here is a non-standard extension to the filtered expression.