1use peg::parser;23pub mod expr;4use expr::{Expr, Literal};56enum Suffix {7 String(String),8 Expression(Expr),9 Apply(expr::Args),10}1112parser! {13 grammar jsonnet_parser() for str {14 rule delimiter() = quiet!{__() "," __()} / expected!("<elements delimiter>")15 rule _() = quiet!{[' ' | '\n' | '\t']+} / expected!("<whitespace>")16 rule __() = quiet!{[' ' | '\n' | '\t']*}17 rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().nth(0).unwrap()}18 rule digit() -> char = d:$(['0'..='9']) {d.chars().nth(0).unwrap()}19 rule int() -> u32 = a:$(digit()+) { a.parse().unwrap() }20 rule number() -> f64 = quiet!{a:$((['-'|'+'])? int() ("." int())? (['e'|'E'] (s:['+'|'-'])? int())?) { a.parse().unwrap() }} / expected!("<number>")21 rule id() -> String = quiet!{ !("local" / "super" / "self" / "true" / "false" / "null" / "$" / "if" / "then" / "else") s:$(alpha() (alpha() / digit())*) {s.to_owned()}} / expected!("<identifier>")2223 pub rule positional_param() -> expr::Param = name:id() {expr::Param::Positional(name)}24 pub rule named_param() -> expr::Param = name:id() __() "=" __() expr:boxed_expr() {expr::Param::Named(name, expr)}25 pub rule params() -> expr::Params26 = positionals:(positional_param() ** delimiter()) delimiter() named:(named_param() ** delimiter()) {27 expr::Params([&positionals[..], &named[..]].concat())28 }29 / named:(named_param() ** delimiter()) {expr::Params(named)}30 / positionals:(positional_param() ** delimiter()) {expr::Params(positionals)}31 / {expr::Params(Vec::new())}3233 pub rule positional_arg() -> expr::Arg = quiet!{name:boxed_expr() {expr::Arg::Positional(name)}}/expected!("<positional arg>")34 pub rule named_arg() -> expr::Arg = quiet!{name:id() __() "=" __() expr:boxed_expr() {expr::Arg::Named(name, expr)}}/expected!("<named arg>")35 pub rule args() -> expr::Args36 = positionals:(positional_arg() ** delimiter()) delimiter() named:(named_arg() ** delimiter()) {37 expr::Args([&positionals[..], &named[..]].concat())38 }39 / named:(named_arg() ** delimiter()) {expr::Args(named)}40 / positionals:(positional_arg() ** delimiter()) {expr::Args(positionals)}41 / {expr::Args(Vec::new())}4243 pub rule bind() -> expr::Bind44 = name:id() __() "=" __() expr:boxed_expr() {expr::Bind::Value(name, expr)}45 / name:id() __() "(" __() params:params() __() ")" __() "=" __() expr:boxed_expr() {expr::Bind::Function(name, params, expr)}46 pub rule assertion() -> expr::AssertStmt = "assert" _() cond:boxed_expr() msg:(__() ":" __() e:boxed_expr() {e})? { expr::AssertStmt(cond, msg) }47 pub rule string() -> String48 = "\"" str:$((!['"'][_])+) "\"" {str.to_owned()}49 / "'" str:$((!['\''][_])+) "'" {str.to_owned()}50 pub rule field_name() -> expr::FieldName51 = name:id() {expr::FieldName::Fixed(name)}52 / name:string() {expr::FieldName::Fixed(name)}53 / "[" __() expr:boxed_expr() __() "]" {expr::FieldName::Dyn(expr)}54 pub rule visibility() -> expr::Visibility55 = ":::" {expr::Visibility::Unhide}56 / "::" {expr::Visibility::Hidden}57 / ":" {expr::Visibility::Normal}58 pub rule field() -> expr::FieldMember59 = name:field_name() __() plus:"+"? __() visibility:visibility() __() value:expr() {expr::FieldMember::Value{60 name,61 plus: plus.is_some(),62 visibility,63 value,64 }}65 / name:field_name() __() "(" __() params:params() __() ")" __() visibility:visibility() __() value:expr() {expr::FieldMember::Function{66 name,67 params,68 visibility,69 value,70 }}71 pub rule member() -> expr::Member72 = "local" _() bind:bind() {expr::Member::BindStmt(bind)}73 / assertion:assertion() {expr::Member::AssertStmt(assertion)}74 / field:field() {expr::Member::Field(field)}75 pub rule obj_body() -> expr::ObjBody = members:(member() ** delimiter()) delimiter()? {expr::ObjBody::MemberList(members)}76 pub rule ifspec() -> expr::IfSpec = "if" _() expr:boxed_expr() {expr::IfSpec(expr)}77 pub rule forspec() -> expr::ForSpec = "for" _() id:id() _() "in" _() ifs:ifspec()* {expr::ForSpec(id, ifs)}78 pub rule bind_expr() -> Expr = bind:bind() {Expr::Bind(bind)}79 pub rule local_expr() -> Expr = "local" _() binds:(bind() ** delimiter()) __() ";" __() expr:boxed_expr() { Expr::LocalExpr(binds, expr) }80 pub rule string_expr() -> Expr = s:string() {Expr::Str(s)}81 pub rule parened_expr() -> Expr = "(" e:boxed_expr() ")" {Expr::Parened(e)}82 pub rule obj_expr() -> Expr = "{" __() body:obj_body() __() "}" {Expr::Obj(body)}83 pub rule array_expr() -> Expr = "[" __() elems:(expr() ** delimiter()) __() delimiter()? "]" {Expr::Arr(elems)}84 pub rule array_comp_expr() -> Expr = "[" __() expr:boxed_expr() delimiter()? fors:forspec()+ __() "]" {Expr::ArrComp(expr, fors)}85 pub rule index_expr() -> Expr86 = val:boxed_expr() "." idx:id() {Expr::Index(val, Box::new(Expr::Str(idx)))}87 / val:boxed_expr() "[" key:boxed_expr() "]" {Expr::Index(val, key)}88 pub rule slice_expr() -> Expr89 = value:boxed_expr() "[" start:boxed_expr()? ":" pair:(end:boxed_expr()? step:(":" e:boxed_expr() {e})? {(end, step)})? "]" {90 if let Some((end, step)) = pair {91 Expr::Slice { value, start, end, step }92 }else{93 Expr::Slice{ value, start, end: None, step: None }94 }95 }96 pub rule number_expr() -> Expr = n:number() { expr::Expr::Num(n) }97 pub rule var_expr() -> Expr = n:id() { expr::Expr::Var(n) }98 pub rule if_then_else_expr() -> Expr = cond:ifspec() _() "then" _() cond_then:boxed_expr() cond_else:(_() "else" _() e:boxed_expr() {e})? {Expr::IfElse{99 cond,100 cond_then,101 cond_else,102 }}103 pub rule expr_basic() -> Expr104 = "null" {Expr::Literal(Literal::Null)}105 / "true" {Expr::Literal(Literal::True)} / "false" {Expr::Literal(Literal::False)}106 / "self" {Expr::Literal(Literal::This)} / "$" {Expr::Literal(Literal::Dollar)}107 / "super" {Expr::Literal(Literal::Super)}108109 / string_expr() / number_expr()110 / array_expr()111 / array_comp_expr()112 / obj_expr()113 / array_expr()114 / array_comp_expr()115116 / var_expr()117 / if_then_else_expr()118 / local_expr()119120 rule expr_suffix() -> Suffix121 = "." __() s:id() { Suffix::String(s) }122 / "[" __() s:expr() __() "]" { Suffix::Expression(s) }123 / "(" __() args:args() __() ")" { Suffix::Apply(args) }124125 rule expr() -> Expr126 = a:precedence! {127 a:(@) __() "||" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Or, Box::new(b))}128 --129 a:(@) __() "&&" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::And, Box::new(b))}130 --131 a:(@) __() "|" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::BitOr, Box::new(b))}132 --133 a:@ __() "^" __() b:(@) {Expr::BinaryOp(Box::new(a), expr::BinaryOp::BitXor, Box::new(b))}134 --135 a:(@) __() "&" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::BitAnd, Box::new(b))}136 --137 a:(@) __() "==" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Eq, Box::new(b))}138 a:(@) __() "!=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Ne, Box::new(b))}139 --140 a:(@) __() "<" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Lt, Box::new(b))}141 a:(@) __() ">" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Gt, Box::new(b))}142 a:(@) __() "<=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Lte, Box::new(b))}143 a:(@) __() ">=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Gte, Box::new(b))}144 --145 a:(@) __() "<<" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Lhs, Box::new(b))}146 a:(@) __() ">>" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Rhs, Box::new(b))}147 --148 a:(@) __() "+" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Add, Box::new(b))}149 a:(@) __() "-" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Sub, Box::new(b))}150 --151 a:(@) __() "*" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Mul, Box::new(b))}152 a:(@) __() "/" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Div, Box::new(b))}153 a:(@) __() "%" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOp::Mod, Box::new(b))}154 --155 e:expr_basic() {e}156 "(" __() e:expr_basic() __() ")" {Expr::Parened(Box::new(e))}157 } suffixes:(__() suffix:expr_suffix() {suffix})* {158 let mut cur = a;159 for suffix in suffixes {160 match suffix {161 Suffix::String(index) => {162 cur = Expr::Index(Box::new(cur), Box::new(Expr::Str(index)))163 },164 Suffix::Expression(index) => {165 cur = Expr::Index(Box::new(cur), Box::new(index))166 },167 Suffix::Apply(args) => {168 cur = Expr::Apply(Box::new(cur), args)169 }170 }171 }172 cur173 }174 / e:expr_basic() {e}175176 pub rule boxed_expr() -> Box<Expr> = e:expr() {Box::new(e)}177 pub rule jsonnet() -> Expr = __() e:expr() __() {e}178 }179}180181182pub fn parse(str: &str) -> Result<Expr, peg::error::ParseError<peg::str::LineCol>> {183 jsonnet_parser::jsonnet(str)184}185186#[cfg(test)]187pub mod tests {188 use super::{expr::*, parse};189 #[test]190 fn empty_object() {191 assert_eq!(parse("{}").unwrap(), Expr::Obj(ObjBody::MemberList(vec![])),);192 }193 #[test]194 fn basic_math() {195 assert_eq!(196 parse("2+2*2").unwrap(),197 Expr::BinaryOp(198 Box::new(Expr::Num(2.0)),199 BinaryOp::Add,200 Box::new(Expr::BinaryOp(201 Box::new(Expr::Num(2.0)),202 BinaryOp::Mul,203 Box::new(Expr::Num(2.0))204 ))205 )206 );207 }208}