difftreelog
refactor(parser) make parser parse stdlib successfully
in: master
4 files changed
crates/jsonnet-parser/Cargo.tomldiffbeforeafterboth--- a/crates/jsonnet-parser/Cargo.toml
+++ b/crates/jsonnet-parser/Cargo.toml
@@ -11,3 +11,6 @@
[dependencies]
peg = "0.6.2"
+
+[dev-dependencies]
+jsonnet-stdlib = { version = "0.1.0", path = "../jsonnet-stdlib" }
crates/jsonnet-parser/README.mddiffbeforeafterbothno changes
crates/jsonnet-parser/src/expr.rsdiffbeforeafterboth--- a/crates/jsonnet-parser/src/expr.rs
+++ b/crates/jsonnet-parser/src/expr.rs
@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
#[derive(Debug, Clone, PartialEq)]
pub enum FieldName {
/// {fixed: 2}
@@ -20,25 +22,18 @@
pub struct AssertStmt(pub Box<Expr>, pub Option<Box<Expr>>);
#[derive(Debug, Clone, PartialEq)]
-pub enum FieldMember {
- Value {
- name: FieldName,
- plus: bool,
- visibility: Visibility,
- value: Expr,
- },
- Function {
- name: FieldName,
- params: ParamsDesc,
- visibility: Visibility,
- value: Expr,
- },
+pub struct FieldMember {
+ pub name: FieldName,
+ pub plus: bool,
+ pub params: Option<ParamsDesc>,
+ pub visibility: Visibility,
+ pub value: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Member {
Field(FieldMember),
- BindStmt(Bind),
+ BindStmt(BindSpec),
AssertStmt(AssertStmt),
}
@@ -50,7 +45,7 @@
Not,
}
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
pub enum BinaryOpType {
Mul,
Div,
@@ -80,73 +75,90 @@
Or,
}
+/// name, default value
#[derive(Debug, Clone, PartialEq)]
-pub enum Param {
- Positional(String),
- Named(String, Box<Expr>),
-}
-
+pub struct Param(pub String, pub Option<Box<Expr>>);
+/// Defined function parameters
#[derive(Debug, Clone, PartialEq)]
pub struct ParamsDesc(pub Vec<Param>);
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Arg {
- Positional(Box<Expr>),
- Named(String, Box<Expr>),
+impl ParamsDesc {
+ pub fn with_defaults(&self) -> Vec<Param> {
+ self.0
+ .iter()
+ .filter(|e| e.1.is_some())
+ .map(|e| e.clone())
+ .collect()
+ }
}
#[derive(Debug, Clone, PartialEq)]
+pub struct Arg(pub Option<String>, pub Box<Expr>);
+#[derive(Debug, Clone, PartialEq)]
pub struct ArgsDesc(pub Vec<Arg>);
#[derive(Debug, Clone, PartialEq)]
-pub enum Bind {
- Value(String, Box<Expr>),
- Function(String, ParamsDesc, Box<Expr>),
+pub struct BindSpec {
+ pub name: String,
+ pub params: Option<ParamsDesc>,
+ pub value: Box<Expr>,
}
#[derive(Debug, Clone, PartialEq)]
-pub struct IfSpec(pub Box<Expr>);
+pub struct IfSpecData(pub Box<Expr>);
#[derive(Debug, Clone, PartialEq)]
-pub struct ForSpec(pub String, pub Vec<IfSpec>);
+pub struct ForSpecData(pub String, pub Box<Expr>);
#[derive(Debug, Clone, PartialEq)]
pub enum CompSpec {
- IfSpec(IfSpec),
- ForSpec(ForSpec),
+ IfSpec(IfSpecData),
+ ForSpec(ForSpecData),
}
#[derive(Debug, Clone, PartialEq)]
pub enum ObjBody {
MemberList(Vec<Member>),
ObjComp {
- pre_locals: Vec<Bind>,
+ pre_locals: Vec<BindSpec>,
key: Box<Expr>,
value: Box<Expr>,
- post_locals: Vec<Bind>,
- first: ForSpec,
+ post_locals: Vec<BindSpec>,
+ first: ForSpecData,
rest: Vec<CompSpec>,
},
}
#[derive(Debug, Clone, PartialEq)]
-pub enum ValueType {
+pub enum LiteralType {
+ This,
+ Super,
+ Dollar,
Null,
True,
False,
}
+impl Display for LiteralType {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ use LiteralType::*;
+ match self {
+ This => write!(f, "this"),
+ Null => write!(f, "null"),
+ True => write!(f, "true"),
+ False => write!(f, "false"),
+ _ => panic!("non printable item"),
+ }
+ }
+}
#[derive(Debug, Clone, PartialEq)]
-pub enum LiteralType {
- This,
- Super,
- Dollar,
+pub struct SliceDesc {
+ pub start: Option<Box<Expr>>,
+ pub end: Option<Box<Expr>>,
+ pub step: Option<Box<Expr>>,
}
/// Syntax base
#[derive(Debug, Clone, PartialEq)]
pub enum Expr {
- Value(ValueType),
- /// Plain value: null/true/false
Literal(LiteralType),
/// String value: "hello"
@@ -169,7 +181,7 @@
/// ]
/// ],
/// ```
- ArrComp(Box<Expr>, Vec<ForSpec>),
+ ArrComp(Box<Expr>, ForSpecData, Vec<CompSpec>),
/// Object: {a: 2}
Obj(ObjBody),
@@ -179,33 +191,48 @@
/// (obj)
Parened(Box<Expr>),
+ /// Params in function definition
+ /// hello, world, test = 2
Params(ParamsDesc),
+ /// Args in function call
+ /// 2 + 2, 3, named = 6
Args(ArgsDesc),
+ /// -2
UnaryOp(UnaryOpType, Box<Expr>),
+ /// 2 - 2
BinaryOp(Box<Expr>, BinaryOpType, Box<Expr>),
+ /// assert 2 == 2 : "Math is broken"
AssertExpr(AssertStmt, Box<Expr>),
- LocalExpr(Vec<Bind>, Box<Expr>),
+ /// local a = 2; { b: a }
+ LocalExpr(Vec<BindSpec>, Box<Expr>),
- Bind(Bind),
+ /// a = 3
+ Bind(BindSpec),
+ /// import "hello"
Import(String),
+ /// importStr "file.txt"
ImportStr(String),
+ /// error "I'm broken"
Error(Box<Expr>),
+ /// a(b, c)
Apply(Box<Expr>, ArgsDesc),
+ ///
Select(Box<Expr>, String),
+ /// a[b]
Index(Box<Expr>, Box<Expr>),
- Slice {
- value: Box<Expr>,
- start: Option<Box<Expr>>,
- end: Option<Box<Expr>>,
- step: Option<Box<Expr>>,
- },
+ /// a[1::2]
+ Slice(Box<Expr>, SliceDesc),
+ /// function(x) x
Function(ParamsDesc, Box<Expr>),
+ /// if true == false then 1 else 2
IfElse {
- cond: IfSpec,
+ cond: IfSpecData,
cond_then: Box<Expr>,
cond_else: Option<Box<Expr>>,
},
- IfSpec(IfSpec),
- ForSpec(ForSpec),
+ /// if 2 = 3
+ IfSpec(IfSpecData),
+ /// for elem in array
+ ForSpec(ForSpecData),
}
crates/jsonnet-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jsonnet-parser/src/lib.rs
+++ b/crates/jsonnet-parser/src/lib.rs
@@ -7,188 +7,228 @@
enum Suffix {
String(String),
+ Slice(SliceDesc),
Expression(Expr),
Apply(expr::ArgsDesc),
+ Extend(expr::ObjBody),
}
parser! {
grammar jsonnet_parser() for str {
- rule delimiter() = quiet!{__() "," __()} / expected!("<elements delimiter>")
- rule _() = quiet!{[' ' | '\n' | '\t']+} / expected!("<whitespace>")
- rule __() = quiet!{[' ' | '\n' | '\t']*}
+ use peg::ParseLiteral;
+
+ /// Standard C-like comments
+ rule comment() = "//" (!['\n'][_])* "\n" / "/*" ((!("*/")[_][_])/("\\" "*/"))* "*/"
+ rule _() = ([' ' | '\n' | '\t'] / comment())*
+
+ /// For comma-delimited elements
+ rule comma() = quiet!{_ "," _} / expected!("<comma>")
rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().nth(0).unwrap()}
rule digit() -> char = d:$(['0'..='9']) {d.chars().nth(0).unwrap()}
- rule int() -> u32 = a:$(digit()+) { a.parse().unwrap() }
- rule number() -> f64 = quiet!{a:$((['-'|'+'])? int() ("." int())? (['e'|'E'] (s:['+'|'-'])? int())?) { a.parse().unwrap() }} / expected!("<number>")
- rule id() -> String = quiet!{ !("local" / "super" / "self" / "true" / "false" / "null" / "$" / "if" / "then" / "else" / "function") s:$(alpha() (alpha() / digit())*) {s.to_owned()}} / expected!("<identifier>")
+ rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']
+ /// Sequence of digits
+ rule uint() -> u32 = a:$(digit()+) { a.parse().unwrap() }
+ /// Number in scientific notation format
+ rule number() -> f64 = quiet!{a:$(uint() ("." uint())? (['e'|'E'] (s:['+'|'-'])? uint())?) { a.parse().unwrap() }} / expected!("<number>")
+
+ /// Reserved word followed by any non-alphanumberic
+ rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()
+ rule id() -> String = quiet!{ !reserved() s:$(alpha() (alpha() / digit())*) {s.to_owned()}} / expected!("<identifier>")
+ rule keyword(id: &'static str) = ##parse_string_literal(id) end_of_ident()
- pub rule positional_param() -> expr::Param = name:id() {expr::Param::Positional(name)}
- pub rule named_param() -> expr::Param = name:id() __() "=" __() expr:boxed_expr() {expr::Param::Named(name, expr)}
+ pub rule param() -> expr::Param = name:id() expr:(_ "=" _ expr:boxed_expr(){expr})? { expr::Param(name, expr) }
pub rule params() -> expr::ParamsDesc
- = positionals:(positional_param() ** delimiter()) named: (delimiter() named:(named_param() ** delimiter()) {named})? {
- if named.is_some() {
- expr::ParamsDesc([&positionals[..], &named.unwrap()[..]].concat())
- } else {
- expr::ParamsDesc(positionals)
+ = params:(param() ** comma()) {
+ let mut defaults_started = false;
+ for param in ¶ms {
+ defaults_started = defaults_started || param.1.is_some();
+ assert_eq!(defaults_started, param.1.is_some(), "defauld parameters should be used after all positionals");
}
+ expr::ParamsDesc(params)
}
- / named:(named_param() ** delimiter()) {expr::ParamsDesc(named)}
- / {expr::ParamsDesc(Vec::new())}
+ / { expr::ParamsDesc(Vec::new()) }
- pub rule positional_arg() -> expr::Arg = quiet!{name:boxed_expr() {expr::Arg::Positional(name)}}/expected!("<positional arg>")
- pub rule named_arg() -> expr::Arg = quiet!{name:id() __() "=" __() expr:boxed_expr() {expr::Arg::Named(name, expr)}}/expected!("<named arg>")
+ pub rule arg() -> expr::Arg
+ = name:id() _ "=" _ expr:boxed_expr() {expr::Arg(Some(name), expr)}
+ / expr:boxed_expr() {expr::Arg(None, expr)}
pub rule args() -> expr::ArgsDesc
- = positionals:(positional_arg() ** delimiter()) named: (delimiter() named:(named_arg() ** delimiter()) {named})? {
- if named.is_some() {
- expr::ArgsDesc([&positionals[..], &named.unwrap()[..]].concat())
- } else {
- expr::ArgsDesc(positionals)
+ = args:arg() ** comma() comma()? {
+ let mut named_started = false;
+ for arg in &args {
+ named_started = named_started || arg.0.is_some();
+ assert_eq!(named_started, arg.0.is_some(), "named args should be used after all positionals");
}
+ expr::ArgsDesc(args)
}
- / named:(named_arg() ** delimiter()) {expr::ArgsDesc(named)}
- / {expr::ArgsDesc(Vec::new())}
+ / { expr::ArgsDesc(Vec::new()) }
- pub rule bind() -> expr::Bind
- = name:id() __() "=" __() expr:boxed_expr() {expr::Bind::Value(name, expr)}
- / name:id() __() "(" __() params:params() __() ")" __() "=" __() expr:boxed_expr() {expr::Bind::Function(name, params, expr)}
- pub rule assertion() -> expr::AssertStmt = "assert" _() cond:boxed_expr() msg:(__() ":" __() e:boxed_expr() {e})? { expr::AssertStmt(cond, msg) }
+ pub rule bind() -> expr::BindSpec
+ = name:id() _ "=" _ expr:boxed_expr() {expr::BindSpec{name, params: None, value: expr}}
+ / name:id() _ "(" _ params:params() _ ")" _ "=" _ expr:boxed_expr() {expr::BindSpec{name, params: Some(params), value: expr}}
+ pub rule assertion() -> expr::AssertStmt = keyword("assert") _ cond:boxed_expr() msg:(_ ":" _ e:boxed_expr() {e})? { expr::AssertStmt(cond, msg) }
pub rule string() -> String
- = "\"" str:$((!['"'][_])*) "\"" {str.to_owned()}
+ = "\"" str:$(("\\\"" / !['"'][_])*) "\"" {str.to_owned()}
/ "'" str:$((!['\''][_])*) "'" {str.to_owned()}
pub rule field_name() -> expr::FieldName
= name:id() {expr::FieldName::Fixed(name)}
/ name:string() {expr::FieldName::Fixed(name)}
- / "[" __() expr:boxed_expr() __() "]" {expr::FieldName::Dyn(expr)}
+ / "[" _ expr:boxed_expr() _ "]" {expr::FieldName::Dyn(expr)}
pub rule visibility() -> expr::Visibility
= ":::" {expr::Visibility::Unhide}
/ "::" {expr::Visibility::Hidden}
/ ":" {expr::Visibility::Normal}
pub rule field() -> expr::FieldMember
- = name:field_name() __() plus:"+"? __() visibility:visibility() __() value:expr() {expr::FieldMember::Value{
+ = name:field_name() _ plus:"+"? _ visibility:visibility() _ value:expr() {expr::FieldMember{
name,
plus: plus.is_some(),
+ params: None,
visibility,
value,
}}
- / name:field_name() __() "(" __() params:params() __() ")" __() visibility:visibility() __() value:expr() {expr::FieldMember::Function{
+ / name:field_name() _ "(" _ params:params() _ ")" _ visibility:visibility() _ value:expr() {expr::FieldMember{
name,
- params,
+ plus: false,
+ params: Some(params),
visibility,
value,
}}
+ pub rule obj_local() -> BindSpec
+ = keyword("local") _ bind:bind() {bind}
pub rule member() -> expr::Member
- = "local" _() bind:bind() {expr::Member::BindStmt(bind)}
+ = bind:obj_local() {expr::Member::BindStmt(bind)}
/ assertion:assertion() {expr::Member::AssertStmt(assertion)}
/ field:field() {expr::Member::Field(field)}
- pub rule obj_body() -> expr::ObjBody = members:(member() ** delimiter()) delimiter()? {expr::ObjBody::MemberList(members)}
- pub rule ifspec() -> expr::IfSpec = "if" _() expr:boxed_expr() {expr::IfSpec(expr)}
- pub rule forspec() -> expr::ForSpec = "for" _() id:id() _() "in" _() ifs:ifspec()* {expr::ForSpec(id, ifs)}
+ pub rule objinside() -> expr::ObjBody
+ = 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})? {
+ expr::ObjBody::ObjComp {
+ pre_locals,
+ key,
+ value,
+ post_locals,
+ first,
+ rest: rest.unwrap_or(Vec::new()),
+ }
+ }
+ / members:(member() ** comma()) comma()? {expr::ObjBody::MemberList(members)}
+ pub rule ifspec() -> IfSpecData = keyword("if") _ expr:boxed_expr() {IfSpecData(expr)}
+ pub rule forspec() -> ForSpecData = keyword("for") _ id:id() _ keyword("in") _ cond:boxed_expr() {ForSpecData(id, cond)}
+ pub rule compspec() -> Vec<expr::CompSpec> = s:(i:ifspec() { expr::CompSpec::IfSpec(i) } / f:forspec() {expr::CompSpec::ForSpec(f)} )+ {s}
pub rule bind_expr() -> Expr = bind:bind() {Expr::Bind(bind)}
- pub rule local_expr() -> Expr = "local" _() binds:(bind() ** delimiter()) __() ";" __() expr:boxed_expr() { Expr::LocalExpr(binds, expr) }
+ pub rule local_expr() -> Expr = keyword("local") _ binds:bind() ** comma() _ ";" _ expr:boxed_expr() { Expr::LocalExpr(binds, expr) }
pub rule string_expr() -> Expr = s:string() {Expr::Str(s)}
pub rule parened_expr() -> Expr = "(" e:boxed_expr() ")" {Expr::Parened(e)}
- pub rule obj_expr() -> Expr = "{" __() body:obj_body() __() "}" {Expr::Obj(body)}
- pub rule array_expr() -> Expr = "[" __() elems:(expr() ** delimiter()) __() delimiter()? "]" {Expr::Arr(elems)}
- pub rule array_comp_expr() -> Expr = "[" __() expr:boxed_expr() delimiter()? fors:forspec()+ __() "]" {Expr::ArrComp(expr, fors)}
+ pub rule obj_expr() -> Expr = "{" _ body:objinside() _ "}" {Expr::Obj(body)}
+ pub rule array_expr() -> Expr = "[" _ elems:(expr() ** comma()) _ comma()? "]" {Expr::Arr(elems)}
+ pub rule array_comp_expr() -> Expr = "[" _ expr:boxed_expr() _ comma()? _ forspec:forspec() _ others:(others: compspec() _ {others})? "]" {Expr::ArrComp(expr, forspec, others.unwrap_or(vec![]))}
pub rule index_expr() -> Expr
= val:boxed_expr() "." idx:id() {Expr::Index(val, Box::new(Expr::Str(idx)))}
/ val:boxed_expr() "[" key:boxed_expr() "]" {Expr::Index(val, key)}
- pub rule slice_expr() -> Expr
- = value:boxed_expr() "[" start:boxed_expr()? ":" pair:(end:boxed_expr()? step:(":" e:boxed_expr() {e})? {(end, step)})? "]" {
- if let Some((end, step)) = pair {
- Expr::Slice { value, start, end, step }
- }else{
- Expr::Slice{ value, start, end: None, step: None }
- }
- }
pub rule number_expr() -> Expr = n:number() { expr::Expr::Num(n) }
pub rule var_expr() -> Expr = n:id() { expr::Expr::Var(n) }
- pub rule if_then_else_expr() -> Expr = cond:ifspec() _() "then" _() cond_then:boxed_expr() cond_else:(_() "else" _() e:boxed_expr() {e})? {Expr::IfElse{
+ 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{
cond,
cond_then,
cond_else,
}}
+
+ pub rule literal() -> Expr
+ = v:(
+ keyword("null") {LiteralType::Null}
+ / keyword("true") {LiteralType::True}
+ / keyword("false") {LiteralType::False}
+ / keyword("self") {LiteralType::This}
+ / keyword("$") {LiteralType::Dollar}
+ / keyword("super") {LiteralType::Super}
+ ) {Expr::Literal(v)}
+
pub rule expr_basic() -> Expr
- = "null" {Expr::Value(ValueType::Null)}
- / "true" {Expr::Value(ValueType::True)} / "false" {Expr::Value(ValueType::False)}
+ = literal()
- / "self" {Expr::Literal(LiteralType::This)} / "$" {Expr::Literal(LiteralType::Dollar)}
- / "super" {Expr::Literal(LiteralType::Super)}
-
/ string_expr() / number_expr()
/ array_expr()
- / array_comp_expr()
/ obj_expr()
/ array_expr()
/ array_comp_expr()
/ var_expr()
+ / local_expr()
/ if_then_else_expr()
- / local_expr()
+ / "-" _ expr:boxed_expr() { Expr::UnaryOp(UnaryOpType::Minus, expr) }
+ / "!" _ expr:boxed_expr() { Expr::UnaryOp(UnaryOpType::Not, expr) }
- / "function" __() "(" __() params:params() __() ")" __() expr:boxed_expr() {Expr::Function(params, expr)}
+ / keyword("function") _ "(" _ params:params() _ ")" _ expr:boxed_expr() {Expr::Function(params, expr)}
+ / assertion:assertion() _ ";" _ expr:boxed_expr() { Expr::AssertExpr(assertion, expr) }
+ / keyword("error") _ expr:boxed_expr() { Expr::Error(expr) }
+
rule expr_basic_with_suffix() -> Expr
- = a:expr_basic() suffixes:(__() suffix:expr_suffix() {suffix})* {
+ = a:expr_basic() suffixes:(_ suffix:expr_suffix() {suffix})* {
let mut cur = a;
for suffix in suffixes {
- match suffix {
- Suffix::String(index) => {
- cur = Expr::Index(Box::new(cur), Box::new(Expr::Str(index)))
- },
- Suffix::Expression(index) => {
- cur = Expr::Index(Box::new(cur), Box::new(index))
- },
- Suffix::Apply(args) => {
- cur = Expr::Apply(Box::new(cur), args)
- }
+ cur = match suffix {
+ Suffix::String(index) => Expr::Index(Box::new(cur), Box::new(Expr::Str(index))),
+ Suffix::Slice(desc) => Expr::Slice(Box::new(cur), desc),
+ Suffix::Expression(index) => Expr::Index(Box::new(cur), Box::new(index)),
+ Suffix::Apply(args) => Expr::Apply(Box::new(cur), args),
+ Suffix::Extend(body) => Expr::ObjExtend(box cur, body),
}
}
cur
}
+ pub rule slice_desc() -> SliceDesc
+ = start:boxed_expr()? _ ":" _ pair:(end:boxed_expr()? _ step:(":" _ e:boxed_expr() {e})? {(end, step)})? {
+ if let Some((end, step)) = pair {
+ SliceDesc { start, end, step }
+ }else{
+ SliceDesc { start, end: None, step: None }
+ }
+ }
+
rule expr_suffix() -> Suffix
- = "." __() s:id() { Suffix::String(s) }
- / "[" __() s:expr() __() "]" { Suffix::Expression(s) }
- / "(" __() args:args() __() ")" { Suffix::Apply(args) }
+ = "." _ s:id() { Suffix::String(s) }
+ / "[" _ s:slice_desc() _ "]" { Suffix::Slice(s) }
+ / "[" _ s:expr() _ "]" { Suffix::Expression(s) }
+ / "(" _ args:args() _ ")" (_ keyword("tailstrict"))? { Suffix::Apply(args) }
+ / "{" _ body:objinside() _ "}" { Suffix::Extend(body) }
rule expr() -> Expr
= a:precedence! {
- a:(@) __() "||" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Or, Box::new(b))}
+ a:(@) _ "||" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Or, Box::new(b))}
--
- a:(@) __() "&&" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::And, Box::new(b))}
+ a:(@) _ "&&" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::And, Box::new(b))}
--
- a:(@) __() "|" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::BitOr, Box::new(b))}
+ a:(@) _ "|" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::BitOr, Box::new(b))}
--
- a:@ __() "^" __() b:(@) {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::BitXor, Box::new(b))}
+ a:@ _ "^" _ b:(@) {Expr::BinaryOp(Box::new(a), BinaryOpType::BitXor, Box::new(b))}
--
- a:(@) __() "&" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::BitAnd, Box::new(b))}
+ a:(@) _ "&" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::BitAnd, Box::new(b))}
--
- a:(@) __() "==" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Eq, Box::new(b))}
- a:(@) __() "!=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Ne, Box::new(b))}
+ a:(@) _ "==" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Eq, Box::new(b))}
+ a:(@) _ "!=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Ne, Box::new(b))}
--
- a:(@) __() "<" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Lt, Box::new(b))}
- a:(@) __() ">" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Gt, Box::new(b))}
- a:(@) __() "<=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Lte, Box::new(b))}
- a:(@) __() ">=" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Gte, Box::new(b))}
+ a:(@) _ "<" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lt, Box::new(b))}
+ a:(@) _ ">" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Gt, Box::new(b))}
+ a:(@) _ "<=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lte, Box::new(b))}
+ a:(@) _ ">=" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Gte, Box::new(b))}
--
- a:(@) __() "<<" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Lhs, Box::new(b))}
- a:(@) __() ">>" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Rhs, Box::new(b))}
+ a:(@) _ "<<" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Lhs, Box::new(b))}
+ a:(@) _ ">>" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Rhs, Box::new(b))}
--
- a:(@) __() "+" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Add, Box::new(b))}
- a:(@) __() "-" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Sub, Box::new(b))}
+ a:(@) _ "+" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Add, Box::new(b))}
+ a:(@) _ "-" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Sub, Box::new(b))}
--
- a:(@) __() "*" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Mul, Box::new(b))}
- a:(@) __() "/" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Div, Box::new(b))}
- a:(@) __() "%" __() b:@ {Expr::BinaryOp(Box::new(a), expr::BinaryOpType::Mod, Box::new(b))}
+ a:(@) _ "*" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Mul, Box::new(b))}
+ a:(@) _ "/" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Div, Box::new(b))}
+ a:(@) _ "%" _ b:@ {Expr::BinaryOp(Box::new(a), BinaryOpType::Mod, Box::new(b))}
--
e:expr_basic_with_suffix() {e}
- "(" __() e:boxed_expr() __() ")" {Expr::Parened(e)}
+ "(" _ e:boxed_expr() _ ")" {Expr::Parened(e)}
}
/ e:expr_basic_with_suffix() {e}
pub rule boxed_expr() -> Box<Expr> = e:expr() {Box::new(e)}
- pub rule jsonnet() -> Expr = __() e:expr() __() {e}
+ pub rule jsonnet() -> Expr = _ e:expr() _ {e}
}
}
@@ -220,7 +260,29 @@
);
}
+ /// Comments should not affect parsing
#[test]
+ fn comments() {
+ assert_eq!(
+ parse("2//comment\n+//comment\n3/*test*/*/*test*/4").unwrap(),
+ Expr::BinaryOp(
+ box Expr::Num(2.0),
+ BinaryOpType::Add,
+ box Expr::BinaryOp(box Expr::Num(3.0), BinaryOpType::Mul, box Expr::Num(4.0))
+ )
+ );
+ }
+
+ /// Comments should be able to be escaped
+ #[test]
+ fn comment_escaping() {
+ assert_eq!(
+ parse("2/*\\*/+*/ - 22").unwrap(),
+ Expr::BinaryOp(box Expr::Num(2.0), BinaryOpType::Sub, box Expr::Num(22.0))
+ );
+ }
+
+ #[test]
fn suffix_comparsion() {
use Expr::*;
assert_eq!(
@@ -228,11 +290,70 @@
BinaryOp(
box Apply(
box Index(box Var("std".to_owned()), box Str("type".to_owned())),
- ArgsDesc(vec![Arg::Positional(box Var("a".to_owned()))])
+ ArgsDesc(vec![Arg(None, box Var("a".to_owned()))])
),
BinaryOpType::Eq,
box Str("string".to_owned())
)
);
}
+
+ #[test]
+ fn array_comp() {
+ use Expr::*;
+ assert_eq!(
+ parse("[std.deepJoin(x) for x in arr]").unwrap(),
+ ArrComp(
+ box Apply(
+ box Index(box Var("std".to_owned()), box Str("deepJoin".to_owned())),
+ ArgsDesc(vec![Arg(None, box Var("x".to_owned()))])
+ ),
+ ForSpecData("x".to_owned(), box Var("arr".to_owned())),
+ vec![]
+ ),
+ )
+ }
+
+ #[test]
+ fn array_comp_with_ifs() {
+ use Expr::*;
+ assert_eq!(
+ parse("[k for k in std.objectFields(patch) if patch[k] == null]").unwrap(),
+ ArrComp(
+ box Var("k".to_owned()),
+ ForSpecData(
+ "k".to_owned(),
+ box Apply(
+ box Index(
+ box Var("std".to_owned()),
+ box Str("objectFields".to_owned())
+ ),
+ ArgsDesc(vec![Arg(None, box Var("patch".to_owned()))])
+ )
+ ),
+ vec![CompSpec::IfSpec(IfSpecData(box BinaryOp(
+ box Index(box Var("patch".to_owned()), box Var("k".to_owned())),
+ BinaryOpType::Eq,
+ box Literal(LiteralType::Null)
+ )))]
+ ),
+ );
+ }
+
+ #[test]
+ fn reserved() {
+ use Expr::*;
+ assert_eq!(parse("null").unwrap(), Literal(LiteralType::Null));
+ assert_eq!(parse("nulla").unwrap(), Var("nulla".to_owned()));
+ }
+
+ #[test]
+ fn multiple_args_buf() {
+ parse("a(b, null_fields)").unwrap();
+ }
+
+ #[test]
+ fn can_parse_stdlib() {
+ parse(jsonnet_stdlib::STDLIB_STR).unwrap();
+ }
}