git.delta.rocks / jrsonnet / refs/commits / 45767d31ad1f

1#![feature(box_syntax)]23use peg::parser;45mod expr;6pub use expr::*;78enum Suffix {9	String(String),10	Slice(SliceDesc),11	Expression(Expr),12	Apply(expr::ArgsDesc),13	Extend(expr::ObjBody),14}1516parser! {17	grammar jsonnet_parser() for str {18		use peg::ParseLiteral;1920		/// Standard C-like comments21		rule comment() = "//" (!['\n'][_])* "\n" / "/*" ((!("*/")[_][_])/("\\" "*/"))* "*/"22		rule _() = ([' ' | '\n' | '\t'] / comment())*2324		/// For comma-delimited elements25		rule comma() = quiet!{_ "," _} / expected!("<comma>")26		rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().nth(0).unwrap()}27		rule digit() -> char = d:$(['0'..='9']) {d.chars().nth(0).unwrap()}28		rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']29		/// Sequence of digits30		rule uint() -> u32 = a:$(digit()+) { a.parse().unwrap() }31		/// Number in scientific notation format32		rule number() -> f64 = quiet!{a:$(uint() ("." uint())? (['e'|'E'] (s:['+'|'-'])? uint())?) { a.parse().unwrap() }} / expected!("<number>")3334		/// Reserved word followed by any non-alphanumberic35		rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()36		rule id() -> String = quiet!{ !reserved() s:$(alpha() (alpha() / digit())*) {s.to_owned()}} / expected!("<identifier>")37		rule keyword(id: &'static str) = ##parse_string_literal(id) end_of_ident()3839		pub rule param() -> expr::Param = name:id() expr:(_ "=" _ expr:boxed_expr(){expr})? { expr::Param(name, expr) }40		pub rule params() -> expr::ParamsDesc41			= params:(param() ** comma()) {42				let mut defaults_started = false;43				for param in &params {44					defaults_started = defaults_started || param.1.is_some();45					assert_eq!(defaults_started, param.1.is_some(), "defauld parameters should be used after all positionals");46				}47				expr::ParamsDesc(params)48			}49			/ { expr::ParamsDesc(Vec::new()) }5051		pub rule arg() -> expr::Arg52			= name:id() _ "=" _ expr:boxed_expr() {expr::Arg(Some(name), expr)}53			/ expr:boxed_expr() {expr::Arg(None, expr)}54		pub rule args() -> expr::ArgsDesc55			= args:arg() ** comma() comma()? {56				let mut named_started = false;57				for arg in &args {58					named_started = named_started || arg.0.is_some();59					assert_eq!(named_started, arg.0.is_some(), "named args should be used after all positionals");60				}61				expr::ArgsDesc(args)62			}63			/ { expr::ArgsDesc(Vec::new()) }6465		pub rule bind() -> expr::BindSpec66			= name:id() _ "=" _ expr:boxed_expr() {expr::BindSpec{name, params: None, value: expr}}67			/ name:id() _ "(" _ params:params() _ ")" _ "=" _ expr:boxed_expr() {expr::BindSpec{name, params: Some(params), value: expr}}68		pub rule assertion() -> expr::AssertStmt = keyword("assert") _ cond:boxed_expr() msg:(_ ":" _ e:boxed_expr() {e})? { expr::AssertStmt(cond, msg) }69		pub rule string() -> String70			= "\"" str:$(("\\\"" / !['"'][_])*) "\"" {str.to_owned()}71			/ "'" str:$((!['\''][_])*) "'" {str.to_owned()}72		pub rule field_name() -> expr::FieldName73			= name:id() {expr::FieldName::Fixed(name)}74			/ name:string() {expr::FieldName::Fixed(name)}75			/ "[" _ expr:boxed_expr() _ "]" {expr::FieldName::Dyn(expr)}76		pub rule visibility() -> expr::Visibility77			= ":::" {expr::Visibility::Unhide}78			/ "::" {expr::Visibility::Hidden}79			/ ":" {expr::Visibility::Normal}80		pub rule field() -> expr::FieldMember81			= name:field_name() _ plus:"+"? _ visibility:visibility() _ value:expr() {expr::FieldMember{82				name,83				plus: plus.is_some(),84				params: None,85				visibility,86				value,87			}}88			/ name:field_name() _ "(" _ params:params() _ ")" _ visibility:visibility() _ value:expr() {expr::FieldMember{89				name,90				plus: false,91				params: Some(params),92				visibility,93				value,94			}}95		pub rule obj_local() -> BindSpec96			= keyword("local") _ bind:bind() {bind}97		pub rule member() -> expr::Member98			= bind:obj_local() {expr::Member::BindStmt(bind)}99			/ assertion:assertion() {expr::Member::AssertStmt(assertion)}100			/ field:field() {expr::Member::Field(field)}101		pub rule objinside() -> expr::ObjBody102			= pre_locals:(b: obj_local() comma() {b})* "[" _ key:boxed_expr() _ "]" _ ":" _ value:boxed_expr() post_locals:(comma() b:obj_local() {b})* _ first:forspec() rest:(_ rest:compspec() {rest})? {103				expr::ObjBody::ObjComp {104					pre_locals,105					key,106					value,107					post_locals,108					first,109					rest: rest.unwrap_or(Vec::new()),110				}111			}112			/ members:(member() ** comma()) comma()? {expr::ObjBody::MemberList(members)}113		pub rule ifspec() -> IfSpecData = keyword("if") _ expr:boxed_expr() {IfSpecData(expr)}114		pub rule forspec() -> ForSpecData = keyword("for") _ id:id() _ keyword("in") _ cond:boxed_expr() {ForSpecData(id, cond)}115		pub rule compspec() -> Vec<expr::CompSpec> = s:(i:ifspec() { expr::CompSpec::IfSpec(i) } / f:forspec() {expr::CompSpec::ForSpec(f)} )+ {s}116		pub rule bind_expr() -> Expr = bind:bind() {Expr::Bind(bind)}117		pub rule local_expr() -> Expr = keyword("local") _ binds:bind() ** comma() _ ";" _ expr:boxed_expr() { Expr::LocalExpr(binds, expr) }118		pub rule string_expr() -> Expr = s:string() {Expr::Str(s)}119		pub rule parened_expr() -> Expr = "(" e:boxed_expr() ")" {Expr::Parened(e)}120		pub rule obj_expr() -> Expr = "{" _ body:objinside() _ "}" {Expr::Obj(body)}121		pub rule array_expr() -> Expr = "[" _ elems:(expr() ** comma()) _ comma()? "]" {Expr::Arr(elems)}122		pub rule array_comp_expr() -> Expr = "[" _ expr:boxed_expr() _ comma()? _ forspec:forspec() _ others:(others: compspec() _ {others})? "]" {Expr::ArrComp(expr, forspec, others.unwrap_or(vec![]))}123		pub rule index_expr() -> Expr124			= val:boxed_expr() "." idx:id() {Expr::Index(val, Box::new(Expr::Str(idx)))}125			/ val:boxed_expr() "[" key:boxed_expr() "]" {Expr::Index(val, key)}126		pub rule number_expr() -> Expr = n:number() { expr::Expr::Num(n) }127		pub rule var_expr() -> Expr = n:id() { expr::Expr::Var(n) }128		pub rule if_then_else_expr() -> Expr = cond:ifspec() _ keyword("then") _ cond_then:boxed_expr() cond_else:(_ keyword("else") _ e:boxed_expr() {e})? {Expr::IfElse{129			cond,130			cond_then,131			cond_else,132		}}133134		pub rule literal() -> Expr135			= v:(136				keyword("null") {LiteralType::Null}137				/ keyword("true") {LiteralType::True}138				/ keyword("false") {LiteralType::False}139				/ keyword("self") {LiteralType::This}140				/ keyword("$") {LiteralType::Dollar}141				/ keyword("super") {LiteralType::Super}142			) {Expr::Literal(v)}143144		pub rule expr_basic() -> Expr145			= literal()146147			/ string_expr() / number_expr()148			/ array_expr()149			/ obj_expr()150			/ array_expr()151			/ array_comp_expr()152153			/ var_expr()154			/ local_expr()155			/ if_then_else_expr()156			/ "-" _ expr:boxed_expr() { Expr::UnaryOp(UnaryOpType::Minus, expr) }157			/ "!" _ expr:boxed_expr() { Expr::UnaryOp(UnaryOpType::Not, expr) }158159			/ keyword("function") _ "(" _ params:params() _ ")" _ expr:boxed_expr() {Expr::Function(params, expr)}160			/ assertion:assertion() _ ";" _ expr:boxed_expr() { Expr::AssertExpr(assertion, expr) }161162			/ keyword("error") _ expr:boxed_expr() { Expr::Error(expr) }163164		rule expr_basic_with_suffix() -> Expr165			= a:expr_basic() suffixes:(_ suffix:expr_suffix() {suffix})* {166				let mut cur = a;167				for suffix in suffixes {168					cur = match suffix {169						Suffix::String(index) => Expr::Index(Box::new(cur), Box::new(Expr::Str(index))),170						Suffix::Slice(desc) => Expr::Slice(Box::new(cur), desc),171						Suffix::Expression(index) => Expr::Index(Box::new(cur), Box::new(index)),172						Suffix::Apply(args) => Expr::Apply(Box::new(cur), args),173						Suffix::Extend(body) => Expr::ObjExtend(box cur, body),174					}175				}176				cur177			}178179		pub rule slice_desc() -> SliceDesc180			= start:boxed_expr()? _ ":" _ pair:(end:boxed_expr()? _ step:(":" _ e:boxed_expr() {e})? {(end, step)})? {181				if let Some((end, step)) = pair {182					SliceDesc { start, end, step }183				}else{184					SliceDesc { start, end: None, step: None }185				}186			}187188		rule expr_suffix() -> Suffix189			= "." _ s:id() { Suffix::String(s) }190			/ "[" _ s:slice_desc() _ "]" { Suffix::Slice(s) }191			/ "[" _ s:expr() _ "]" { Suffix::Expression(s) }192			/ "(" _ args:args() _ ")" (_ keyword("tailstrict"))? { Suffix::Apply(args) }193			/ "{" _ body:objinside() _ "}" { Suffix::Extend(body) }194195		rule expr() -> Expr196			= a:precedence! {197				a:(@) _ "||" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Or, Box::new(b))}198				--199				a:(@) _ "&&" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::And, Box::new(b))}200				--201				a:(@) _ "|" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::BitOr, Box::new(b))}202				--203				a:@ _ "^" _ b:(@) {Expr::BinaryOp(Box::new(a), BinaryOpType::BitXor, Box::new(b))}204				--205				a:(@) _ "&" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::BitAnd, Box::new(b))}206				--207				a:(@) _ "==" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Eq, Box::new(b))}208				a:(@) _ "!=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Ne, Box::new(b))}209				--210				a:(@) _ "<" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lt, Box::new(b))}211				a:(@) _ ">" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Gt, Box::new(b))}212				a:(@) _ "<=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lte, Box::new(b))}213				a:(@) _ ">=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Gte, Box::new(b))}214				--215				a:(@) _ "<<" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lhs, Box::new(b))}216				a:(@) _ ">>" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Rhs, Box::new(b))}217				--218				a:(@) _ "+" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Add, Box::new(b))}219				a:(@) _ "-" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Sub, Box::new(b))}220				--221				a:(@) _ "*" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Mul, Box::new(b))}222				a:(@) _ "/" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Div, Box::new(b))}223				a:(@) _ "%" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Mod, Box::new(b))}224				--225				e:expr_basic_with_suffix() {e}226				"(" _ e:boxed_expr() _ ")" {Expr::Parened(e)}227			}228			/ e:expr_basic_with_suffix() {e}229230		pub rule boxed_expr() -> Box<Expr> = e:expr() {Box::new(e)}231		pub rule jsonnet() -> Expr = _ e:expr() _ {e}232	}233}234235// TODO: impl FromStr from Expr236pub fn parse(str: &str) -> Result<Expr, peg::error::ParseError<peg::str::LineCol>> {237	jsonnet_parser::jsonnet(str)238}239240#[cfg(test)]241pub mod tests {242	use super::{expr::*, parse};243	#[test]244	fn empty_object() {245		assert_eq!(parse("{}").unwrap(), Expr::Obj(ObjBody::MemberList(vec![])),);246	}247	#[test]248	fn basic_math() {249		assert_eq!(250			parse("2+2*2").unwrap(),251			Expr::BinaryOp(252				Box::new(Expr::Num(2.0)),253				BinaryOpType::Add,254				Box::new(Expr::BinaryOp(255					Box::new(Expr::Num(2.0)),256					BinaryOpType::Mul,257					Box::new(Expr::Num(2.0))258				))259			)260		);261	}262263	/// Comments should not affect parsing264	#[test]265	fn comments() {266		assert_eq!(267			parse("2//comment\n+//comment\n3/*test*/*/*test*/4").unwrap(),268			Expr::BinaryOp(269				box Expr::Num(2.0),270				BinaryOpType::Add,271				box Expr::BinaryOp(box Expr::Num(3.0), BinaryOpType::Mul, box Expr::Num(4.0))272			)273		);274	}275276	/// Comments should be able to be escaped277	#[test]278	fn comment_escaping() {279		assert_eq!(280			parse("2/*\\*/+*/ - 22").unwrap(),281			Expr::BinaryOp(box Expr::Num(2.0), BinaryOpType::Sub, box Expr::Num(22.0))282		);283	}284285	#[test]286	fn suffix_comparsion() {287		use Expr::*;288		assert_eq!(289			parse("std.type(a) == \"string\"").unwrap(),290			BinaryOp(291				box Apply(292					box Index(box Var("std".to_owned()), box Str("type".to_owned())),293					ArgsDesc(vec![Arg(None, box Var("a".to_owned()))])294				),295				BinaryOpType::Eq,296				box Str("string".to_owned())297			)298		);299	}300301	#[test]302	fn array_comp() {303		use Expr::*;304		assert_eq!(305			parse("[std.deepJoin(x) for x in arr]").unwrap(),306			ArrComp(307				box Apply(308					box Index(box Var("std".to_owned()), box Str("deepJoin".to_owned())),309					ArgsDesc(vec![Arg(None, box Var("x".to_owned()))])310				),311				ForSpecData("x".to_owned(), box Var("arr".to_owned())),312				vec![]313			),314		)315	}316317	#[test]318	fn array_comp_with_ifs() {319		use Expr::*;320		assert_eq!(321			parse("[k for k in std.objectFields(patch) if patch[k] == null]").unwrap(),322			ArrComp(323				box Var("k".to_owned()),324				ForSpecData(325					"k".to_owned(),326					box Apply(327						box Index(328							box Var("std".to_owned()),329							box Str("objectFields".to_owned())330						),331						ArgsDesc(vec![Arg(None, box Var("patch".to_owned()))])332					)333				),334				vec![CompSpec::IfSpec(IfSpecData(box BinaryOp(335					box Index(box Var("patch".to_owned()), box Var("k".to_owned())),336					BinaryOpType::Eq,337					box Literal(LiteralType::Null)338				)))]339			),340		);341	}342343	#[test]344	fn reserved() {345		use Expr::*;346		assert_eq!(parse("null").unwrap(), Literal(LiteralType::Null));347		assert_eq!(parse("nulla").unwrap(), Var("nulla".to_owned()));348	}349350	#[test]351	fn multiple_args_buf() {352		parse("a(b, null_fields)").unwrap();353	}354355	#[test]356	fn can_parse_stdlib() {357		parse(jsonnet_stdlib::STDLIB_STR).unwrap();358	}359}